anyplotlib 0.1.0__py3-none-any.whl

anyplotlib/__init__.py

@@ -0,0 +1,53 @@
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+try:
+    __version__ = _pkg_version("anyplotlib")
+except PackageNotFoundError:  # not installed (e.g. source tree on sys.path)
+    __version__ = "0.0.0+unknown"
+
+from anyplotlib.figure import Figure, GridSpec, SubplotSpec, subplots
+from anyplotlib.axes import Axes, InsetAxes
+from anyplotlib.plot1d import Plot1D, PlotBar
+from anyplotlib.plot1d._plot1d import Line1D
+from anyplotlib.plot2d import Plot2D, PlotMesh
+from anyplotlib.plot3d import Plot3D
+from anyplotlib.plotxy import PlotXY
+from anyplotlib.callbacks import CallbackRegistry, Event
+from anyplotlib import embed
+from anyplotlib.markers import MarkerRegistry, MarkerGroup
+from anyplotlib.widgets import (
+    Widget, RectangleWidget, CircleWidget, AnnularWidget,
+    CrosshairWidget, PolygonWidget, LabelWidget,
+    VLineWidget, HLineWidget, RangeWidget, PlaneWidget,
+)
+
+# ── Global help flag ──────────────────────────────────────────────────────
+# Set to False to suppress help badges on all figures in this session.
+# Default True: badges appear whenever a figure has help text set.
+show_help: bool = True
+
+_COLOR_CYCLE: list[str] = [
+    "#4fc3f7", "#ff7043", "#aed581", "#ffd54f",
+    "#ba68c8", "#4db6ac", "#f06292", "#90a4ae",
+    "#ffb74d", "#a5d6a7",
+]
+
+
+def get_color_cycle() -> list[str]:
+    """Return the default color cycle as a list of CSS hex strings."""
+    return list(_COLOR_CYCLE)
+
+
+__all__ = [
+    "Figure", "GridSpec", "SubplotSpec", "subplots",
+    "Axes", "InsetAxes", "Plot1D", "Plot2D", "PlotMesh", "Plot3D", "PlotBar",
+    "Line1D",
+    "CallbackRegistry", "Event",
+    "MarkerRegistry", "MarkerGroup",
+    "Widget", "RectangleWidget", "CircleWidget", "AnnularWidget",
+    "CrosshairWidget", "PolygonWidget", "LabelWidget",
+    "VLineWidget", "HLineWidget", "RangeWidget", "PlaneWidget",
+    "show_help", "get_color_cycle",
+    "embed",
+    "__version__",
+]

anyplotlib/_base_plot.py

@@ -0,0 +1,229 @@
+"""
+_base_plot.py
+=============
+Shared base classes and mixins for all plot panel types.
+"""
+
+from __future__ import annotations
+
+from contextlib import contextmanager
+
+from anyplotlib.callbacks import _EventMixin
+
+
+class _BasePlot(_EventMixin):
+    """Universal base for Plot1D, Plot2D, PlotBar, and Plot3D.
+
+    Contains methods identical across all four panel types and helper
+    utilities used by view-setter and widget-adder methods.
+
+    Subclasses must define:
+        _state : dict         — the panel state dict
+        _push() -> None       — serialize state and write to parent Figure
+    """
+
+    def configure_pointer_settled(self, ms: int, delta: float = 4) -> None:
+        """Configure the pointer-settled event threshold (ms and pixel delta)."""
+        self._state["pointer_settled_ms"]    = ms
+        self._state["pointer_settled_delta"] = delta
+        self._push()
+
+    _configure_pointer_settled = configure_pointer_settled
+
+    #: Mini-TeX formatting note shared by all label setters.
+    #:
+    #: Label strings support a small TeX subset inside ``$...$`` delimiters,
+    #: rendered by the JS canvas engine (no MathJax needed):
+    #:
+    #: * ``$10^{-3}$`` / ``$x^2$``  — superscripts (exponents)
+    #: * ``$E_F$`` / ``$k_{B}T$``   — subscripts
+    #: * ``$\\alpha$ … $\\Omega$``  — Greek letters
+    #: * ``\\times \\cdot \\pm \\degree \\AA \\infty \\propto \\approx``
+    #:   ``\\leq \\geq \\neq \\partial \\nabla \\hbar \\rightarrow`` — symbols
+    #: * ``$\\mathrm{...}$``        — upright text inside math (letters in
+    #:   math mode are italic by default)
+    #:
+    #: Example: ``plot.set_xlabel(r"$q$ ($\\AA^{-1}$)", fontsize=14)``
+
+    def _set_label(self, key: str, label: str, size_key: str,
+                   fontsize: float | None) -> None:
+        """Store a label string (TeX subset allowed) and its optional size."""
+        self._state[key] = str(label)
+        if fontsize is not None:
+            self._state[size_key] = float(fontsize)
+        self._push()
+
+    def set_title(self, label: str, fontsize: float | None = None) -> None:
+        """Set the panel title.
+
+        Parameters
+        ----------
+        label : str
+            Title text.  Supports the mini-TeX subset (``$10^{-3}$``,
+            ``$\\alpha$``, …) — see the class notes on label formatting.
+        fontsize : float, optional
+            Font size in CSS pixels.  Default 11.  On 2-D panels the title
+            strip grows to fit larger sizes.  1-D and bar titles render in a
+            fixed 12-px strip, so the drawn size is clamped to 11 there.
+        """
+        self._set_label("title", label, "title_size", fontsize)
+
+    def set_axis_off(self) -> None:
+        self._state["axis_visible"] = False
+        self._push()
+
+    def set_axis_on(self) -> None:
+        self._state["axis_visible"] = True
+        self._push()
+
+    @contextmanager
+    def _python_view_push(self):
+        """Context manager for view setters that must signal _view_from_python.
+
+        Sets the flag on entry, yields for state mutations, then pushes
+        and clears the flag on exit.
+        """
+        self._state["_view_from_python"] = True
+        try:
+            yield
+        finally:
+            self._push()
+            self._state["_view_from_python"] = False
+
+    def _make_widget_push_fn(self, widget):
+        """Return a targeted-push closure for a widget.
+
+        Replaces the repeated _tp / _targeted_push closures in every
+        add_*_widget method.
+        """
+        plot_ref, wid_id = self, widget._id
+        def _push():
+            if plot_ref._fig is not None:
+                fields = {k: v for k, v in widget._data.items()
+                          if k not in ("id", "type")}
+                plot_ref._fig._push_widget(plot_ref._id, wid_id, fields)
+        return _push
+
+
+class _PanelMixin:
+    """Mixin for panels that support interactive widgets and tick control.
+
+    Shared by Plot1D, Plot2D, and PlotBar. Provides _push (with widget
+    serialization), widget management, and tick visibility control.
+
+    Subclasses must define:
+        _state : dict
+        _fig   : object
+        _id    : str
+        _widgets : dict[str, Widget]
+    """
+
+    def _push(self) -> None:
+        if self._fig is None:
+            return
+        self._state["overlay_widgets"] = [w.to_dict() for w in self._widgets.values()]
+        self._fig._push(self._id)
+
+    def set_tick_label_size(self, size: float) -> None:
+        """Set the font size of the tick (axis number) labels in CSS pixels.
+
+        Applies to both axes of the panel.  Default 10.
+
+        Parameters
+        ----------
+        size : float
+            Tick label font size in pixels.
+        """
+        self._state["tick_size"] = float(size)
+        self._push()
+
+    def set_ticks_visible(self, visible: bool, *, x: bool | None = None,
+                          y: bool | None = None) -> None:
+        if x is None and y is None:
+            self._state["x_ticks_visible"] = bool(visible)
+            self._state["y_ticks_visible"] = bool(visible)
+        else:
+            if x is not None:
+                self._state["x_ticks_visible"] = bool(x)
+            if y is not None:
+                self._state["y_ticks_visible"] = bool(y)
+        self._push()
+
+    def get_widget(self, wid):
+        """Return the Widget object by ID string or Widget instance."""
+        from anyplotlib.widgets import Widget
+        if isinstance(wid, Widget):
+            wid = wid.id
+        try:
+            return self._widgets[wid]
+        except KeyError:
+            raise KeyError(wid)
+
+    def remove_widget(self, wid) -> None:
+        """Remove a widget by ID string or Widget instance."""
+        from anyplotlib.widgets import Widget
+        if isinstance(wid, Widget):
+            wid = wid.id
+        if wid not in self._widgets:
+            raise KeyError(wid)
+        del self._widgets[wid]
+        self._push()
+
+    def list_widgets(self) -> list:
+        """Return a list of all active widget objects on this panel."""
+        return list(self._widgets.values())
+
+    def clear_widgets(self) -> None:
+        """Remove all interactive overlay widgets from this panel."""
+        self._widgets.clear()
+        self._push()
+
+
+class _MarkerMixin:
+    """Mixin for panels that support static marker collections.
+
+    Shared by Plot1D and Plot2D.
+
+    Subclasses must define:
+        _state : dict
+        markers : MarkerRegistry
+        _push() -> None
+    """
+
+    def _push_markers(self) -> None:
+        self._state["markers"] = self.markers.to_wire_list()
+        self._push()
+
+    def _add_marker(self, mtype: str, name, **kwargs):
+        return self.markers.add(mtype, name, **kwargs)
+
+    def remove_marker(self, marker_type: str, name: str) -> None:
+        """Remove a named marker collection by type and name.
+
+        Parameters
+        ----------
+        marker_type : str
+            Collection type, e.g. ``"points"``, ``"vlines"``.
+        name : str
+            The name used when the collection was created.
+        """
+        self.markers.remove(marker_type, name)
+
+    def clear_markers(self) -> None:
+        """Remove all marker collections from this panel."""
+        self.markers.clear()
+
+    def list_markers(self) -> list:
+        """Return a summary list of all marker collections on this panel.
+
+        Returns
+        -------
+        list of dict
+            Each dict has keys ``"type"``, ``"name"``, and ``"n"``
+            (number of markers in the collection).
+        """
+        out = []
+        for mtype, td in self.markers._types.items():
+            for name, g in td.items():
+                out.append({"type": mtype, "name": name, "n": g._count()})
+        return out

anyplotlib/_electron.py

@@ -0,0 +1,74 @@
+"""
+_electron.py
+============
+Electron app bridge for anyplotlib figures.
+
+Registers figures so their trait changes are forwarded to the Electron
+renderer via stdout, and provides dispatch_event() so the renderer can
+send interaction events back to Python.
+"""
+from __future__ import annotations
+
+import json
+import sys
+import uuid
+
+_figures: dict[str, object] = {}   # fig_id -> Figure
+
+
+def register(fig) -> str:
+    """Register *fig* for bidirectional state sync and return its fig_id."""
+    fig_id = uuid.uuid4().hex[:8]
+    _figures[fig_id] = fig
+
+    def _on_change(change):
+        name = change["name"]
+        value = change["new"]
+        if isinstance(value, (bytes, bytearray)):
+            import base64
+            value = {"buffer": base64.b64encode(value).decode()}
+        emit({"type": "state_update", "fig_id": fig_id, "key": name, "value": value})
+
+    for name in fig.traits(sync=True):
+        if not name.startswith("_"):
+            try:
+                fig.observe(_on_change, names=[name])
+            except Exception:
+                pass
+
+    return fig_id
+
+
+def resize_figure(fig_id: str, width: int, height: int) -> None:
+    """Update fig_width / fig_height and push new layout to the iframe."""
+    fig = _figures.get(fig_id)
+    if fig is None:
+        return
+    try:
+        # Batch both trait changes so _on_resize fires only once each.
+        with fig.hold_trait_notifications():
+            fig.fig_width  = int(width)
+            fig.fig_height = int(height)
+    except Exception:
+        pass
+
+
+def dispatch_event(fig_id: str, event_json: str) -> None:
+    """Apply a frontend interaction event to the registered figure."""
+    fig = _figures.get(fig_id)
+    if fig is None:
+        return
+    try:
+        # Figure.show() registers Figure objects which use _dispatch_event(raw_json_str).
+        # Standalone widgets use _update_from_js(dict, event_type).
+        if hasattr(fig, "_dispatch_event"):
+            fig._dispatch_event(event_json)
+        elif hasattr(fig, "_update_from_js"):
+            fig._update_from_js(json.loads(event_json))
+    except Exception:
+        pass
+
+
+def emit(obj: dict) -> None:
+    sys.stdout.write(f"PLOTAPP:{json.dumps(obj, default=str)}\n")
+    sys.stdout.flush()

anyplotlib/_repr_utils.py

@@ -0,0 +1,345 @@
+"""
+_repr_utils.py
+==============
+
+Produces a self-contained HTML page that renders anywidget Widgets
+interactively without a live Jupyter kernel.
+
+Strategy
+--------
+1. Serialise every synced traitlet value to a plain JSON dict.
+2. Embed that dict and the widget's ``_esm`` source directly in the page.
+3. Provide a minimal model shim (get/set/on/save_changes) so the ESM's
+   render() function works without any Jupyter comm infrastructure.
+4. Import the ESM as a Blob URL and call render({ model, el }).
+
+When resizable=False (the default for documentation) the resize handle is
+hidden via CSS and the iframe is sized exactly to the widget's own dimensions,
+producing a tight, centred embed with no dead space.
+"""
+
+from __future__ import annotations
+
+import json
+from html import escape
+from uuid import uuid4
+
+# Maximum display width (px) for the non-resizable notebook embed.
+# Figures wider than this are scaled down proportionally via CSS transform.
+# 860 px fits comfortably in a standard JupyterLab / VS Code notebook cell.
+MAX_NOTEBOOK_WIDTH = 860
+
+
+# ---------------------------------------------------------------------------
+# Trait serialisation
+# ---------------------------------------------------------------------------
+
+def _widget_state(widget) -> dict:
+    """Return a {name: value} dict of every synced traitlet."""
+    state: dict = {}
+    for name, trait in widget.traits(sync=True).items():
+        if name.startswith("_"):
+            continue
+        raw = getattr(widget, name)
+        if isinstance(raw, (bytes, bytearray)):
+            import base64
+            raw = {"buffer": base64.b64encode(raw).decode("ascii")}
+        state[name] = raw
+    return state
+
+
+def _widget_px(widget) -> tuple[int, int]:
+    """Return (width_px, height_px) for the widget's full rendered size.
+
+    These are the *outer* pixel dimensions of the widget's root DOM element,
+    including any padding the widget JS adds around the canvas grid.
+    """
+    try:
+        kind = type(widget).__name__
+        if kind == "Figure":
+            # figure_esm.js: gridDiv has padding:8px on all sides → +16 each axis
+            return int(widget.fig_width) + 16, int(widget.fig_height) + 16
+        # Viewer1D / Viewer2D — the outerContainer has padding:10px
+        w = int(getattr(widget, "viewer_width",  480))
+        h = int(getattr(widget, "viewer_height", 256))
+        PAD = 20  # 10px padding each side
+        if kind == "Viewer2D":
+            # Add axis canvas gutters (AXIS_SIZE = 40 in viewer2d JS)
+            AXIS = 40
+            w += AXIS + PAD
+            h += AXIS + PAD
+            if getattr(widget, "histogram_visible", False):
+                h_gap = int(getattr(widget, "gap", 10))
+                h_hw  = int(getattr(widget, "histogram_width", 120))
+                w    += h_hw + h_gap
+        else:
+            # Viewer1D: PAD_L=58, PAD_R=12, PAD_T=12, PAD_B=36 + outer 10px pad each side
+            w += 58 + 12 + 20   # PAD_L + PAD_R + outer
+            h += 12 + 36 + 20   # PAD_T + PAD_B + outer
+        return w, h
+    except Exception:
+        return 560, 340
+
+
+# ---------------------------------------------------------------------------
+# HTML builder
+# ---------------------------------------------------------------------------
+
+# Extra CSS injected when resizable=False:
+# - hides every resize-handle div
+# - locks the outermost container to exact pixel dims so it can't grow
+_NO_RESIZE_CSS = """\
+  /* ── resizable=False overrides ─────────────────────────────── */
+  /* Hide all resize handles rendered by the widget JS */
+  div[style*="nwse-resize"],
+  div[title="Drag to resize"],
+  div[title="Drag to resize figure"] {{
+    display: none !important;
+  }}
+  /* Remove any bottom-right padding that was reserved for the handle */
+  #widget-root > div {{
+    padding-bottom: 0 !important;
+    padding-right:  0 !important;
+  }}
+"""
+
+_PAGE_TEMPLATE = """\
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8"/>
+<style>
+  html, body {{
+    margin: 0;
+    padding: 0;
+    background: transparent;
+    overflow: hidden;
+    /* Size the document exactly to the widget so scrollHeight == widget height */
+    width:  {width}px;
+    height: {height}px;
+  }}
+  #widget-root {{
+    display: inline-block;
+    line-height: 0;
+  }}
+{extra_css}\
+</style>
+</head>
+<body>
+<div id="widget-root"></div>
+<script type="module">
+const STATE = {state_json};
+// Identifies this iframe to the parent-page anywidget bridge.
+// null → no Pyodide wiring (plain notebook / static docs embed).
+const FIG_ID = {fig_id_json};
+
+// Loop-prevention flag: set while applying a parent-originated update so
+// set() doesn't double-fire callbacks that save_changes() will also fire.
+let _fromParent = false;
+// Dirty flag: true only when model.set('event_json', ...) was called in the
+// current transaction.
+let _eventJsonDirty = false;
+
+function makeModel(state) {{
+  const _data   = Object.assign({{}}, state);
+  const _cbs    = {{}};
+  const _anyCbs = [];
+  return {{
+    get(key)      {{ return _data[key]; }},
+    set(key, val) {{
+      _data[key] = val;
+      if (key === 'event_json') _eventJsonDirty = true;
+      // Only fire synchronously when NOT processing an inbound awi_state
+      // message (save_changes() will fire listeners once in that path).
+      if (!_fromParent) {{
+        const ev = 'change:' + key;
+        if (_cbs[ev]) for (const cb of [..._cbs[ev]]) try {{ cb({{ new: val }}); }} catch(_) {{}}
+        for (const cb of [..._anyCbs]) try {{ cb(); }} catch(_) {{}}
+      }}
+    }},
+    save_changes() {{
+      for (const [ev, cbs] of Object.entries(_cbs))
+        for (const cb of cbs) try {{ cb({{ new: _data[ev.slice(7)] }}); }} catch(_) {{}}
+      for (const cb of _anyCbs) try {{ cb(); }} catch(_) {{}}
+      // Forward interaction events to the parent-page Pyodide instance.
+      if (!_fromParent && FIG_ID && window.parent !== window && _eventJsonDirty) {{
+        _eventJsonDirty = false;
+        try {{
+          const ev = JSON.parse(_data.event_json || '{{}}');
+          if (ev && ev.source !== 'python') {{
+            window.parent.postMessage(
+              {{ type: 'awi_event', figId: FIG_ID, data: _data.event_json }}, '*');
+          }}
+        }} catch(_) {{}}
+      }} else {{
+        _eventJsonDirty = false;
+      }}
+    }},
+    on(event, cb)  {{
+      if (event === "change") {{ _anyCbs.push(cb); return; }}
+      (_cbs[event] = _cbs[event] || []).push(cb);
+    }},
+    off(event, cb) {{
+      if (!event) {{ for (const k in _cbs) _cbs[k]=[]; _anyCbs.length=0; return; }}
+      if (_cbs[event]) _cbs[event] = _cbs[event].filter(c => c !== cb);
+    }},
+    get model() {{ return this; }},
+  }};
+}}
+
+const esmSource = {esm_json};
+const blob    = new Blob([esmSource], {{ type: "text/javascript" }});
+const blobUrl = URL.createObjectURL(blob);
+const el      = document.getElementById("widget-root");
+const model   = makeModel(STATE);
+
+import(blobUrl).then(mod => {{
+  const renderFn = mod.default?.render ?? mod.render;
+  if (typeof renderFn === "function") {{
+    renderFn({{ model, el }});
+  }} else {{
+    el.textContent = "ESM has no render() export";
+  }}
+}}).catch(err => {{
+  el.textContent = "Widget load error: " + err;
+  console.error(err);
+}});
+
+// ── Inbound state updates from parent-page Pyodide ───────────────────────────
+window.addEventListener('message', (e) => {{
+  if (!e.data || e.data.type !== 'awi_state') return;
+  _fromParent = true;
+  model.set(e.data.key, e.data.value);
+  model.save_changes();
+  _fromParent = false;
+}});
+</script>
+</body>
+</html>
+"""
+
+
+def build_standalone_html(widget, *, resizable: bool = True,
+                           fig_id: str | None = None) -> str:
+    """Return a self-contained HTML page that renders *widget* interactively.
+
+    Parameters
+    ----------
+    widget :
+        Any ``anywidget.AnyWidget`` subclass with ``_esm`` defined.
+    resizable : bool
+        When ``True`` (default) the widget's built-in resize handle is
+        preserved.  When ``False`` the handle is hidden via CSS and the page
+        is sized exactly to the widget's natural dimensions.
+    fig_id : str or None
+        When provided, embedded as ``FIG_ID`` so the parent-page bridge
+        can route ``postMessage`` state updates to this iframe.
+    """
+    state = _widget_state(widget)
+
+    esm = getattr(widget, "_esm", "") or ""
+    if hasattr(esm, "read_text"):
+        esm = esm.read_text(encoding="utf-8")
+    esm = str(esm)
+
+    w, h = _widget_px(widget)
+    extra_css = _NO_RESIZE_CSS.format() if not resizable else ""
+
+    return _PAGE_TEMPLATE.format(
+        width=w,
+        height=h,
+        extra_css=extra_css,
+        state_json=json.dumps(state, default=str),
+        esm_json=json.dumps(esm),
+        fig_id_json=json.dumps(fig_id),
+    )
+
+
+def repr_html_iframe(widget, *, resizable: bool = False,
+                     max_width: int = MAX_NOTEBOOK_WIDTH,
+                     max_height: int = 800) -> str:
+    """Return a centred, responsive ``<iframe srcdoc=...>`` embedding *widget*.
+
+    Parameters
+    ----------
+    widget :
+        Any ``anywidget.AnyWidget`` subclass.
+    resizable : bool
+        Passed to :func:`build_standalone_html`.  Default ``False`` for
+        documentation embeds — hides the resize handle and sizes the iframe
+        exactly to the widget.
+    max_width : int
+        Maximum display width in pixels.  Figures wider than this are scaled
+        down proportionally via ``transform:scale()`` so they never overflow
+        the notebook cell.  Default ``MAX_NOTEBOOK_WIDTH`` (860 px).
+    max_height : int
+        Upper bound on iframe height in pixels (only used when
+        ``resizable=True``).
+    """
+    inner_html = build_standalone_html(widget, resizable=resizable)
+    escaped    = escape(inner_html, quote=True)
+    uid        = str(uuid4()).replace("-", "")
+
+    w, h = _widget_px(widget)
+
+    if not resizable:
+        # ── Responsive fixed-size embed ────────────────────────────────────
+        # The iframe always renders at its native resolution so the widget
+        # is pixel-perfect on wide screens.  On narrower cells a CSS
+        # transform:scale() shrinks it proportionally — CSS transforms
+        # correctly route pointer events so interaction still works.
+        #
+        # The static scale (baked into the style attribute) renders correctly
+        # before JS runs.  requestAnimationFrame defers the first JS
+        # measurement until after layout is complete so offsetWidth is
+        # always valid; the !avail guard prevents a not-yet-reflowed parent
+        # from collapsing the wrapper.
+        init_scale = min(1.0, max_width / w)
+        init_w     = round(w * init_scale)
+        init_h     = round(h * init_scale)
+        scale_css  = f"{init_scale:.6f}".rstrip("0").rstrip(".")
+
+        js = (
+            f"(function(){{"
+            f"var wrap=document.getElementById('vw-{uid}'),"
+            f"ifr=wrap.querySelector('iframe'),"
+            f"nw={w},nh={h};"
+            f"function r(){{"
+            f"var avail=wrap.parentElement?wrap.parentElement.offsetWidth:0;"
+            f"if(!avail)return;"
+            f"var s=Math.min(1,avail/nw);"
+            f"wrap.style.width=Math.round(nw*s)+'px';"
+            f"wrap.style.height=Math.round(nh*s)+'px';"
+            f"ifr.style.transform='scale('+s+')';"
+            f"}}"
+            f"requestAnimationFrame(r);window.addEventListener('resize',r);"
+            f"}})()"
+        )
+
+        return (
+            f'<div style="display:block;text-align:center;line-height:0;margin:8px 0;">'
+            f'<div id="vw-{uid}" style="display:inline-block;overflow:hidden;'
+            f'position:relative;width:{init_w}px;height:{init_h}px;">'
+            f'<iframe srcdoc="{escaped}" frameborder="0" scrolling="no" '
+            f'style="width:{w}px;height:{h}px;border:none;overflow:hidden;display:block;'
+            f'transform-origin:top left;transform:scale({scale_css});'
+            f'position:absolute;top:0;left:0;">'
+            f'</iframe>'
+            f'</div>'
+            f'<script>{js}</script>'
+            f'</div>'
+        )
+    else:
+        # ── Resizable embed (fills cell width, auto-sizes height) ──────────
+        return (
+            f'<iframe id="vw-{uid}" srcdoc="{escaped}" frameborder="0" '
+            f'style="width:100%;height:{h}px;border:none;overflow:hidden;" '
+            f'onload="setTimeout(function(){{'
+            f'var f=document.getElementById(\'vw-{uid}\');'
+            f'if(f&&f.contentWindow&&f.contentWindow.document.body){{'
+            f'f.style.height=Math.min('
+            f'f.contentWindow.document.body.scrollHeight+20,{max_height})+\'px\''
+            f'}}}},'
+            f'300)"></iframe>'
+        )
+