flet-charts 0.85.0.dev2__tar.gz → 0.85.0.dev3__tar.gz

{flet_charts-0.85.0.dev2/src/flet_charts.egg-info → flet_charts-0.85.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-charts
-Version: 0.85.0.dev2
+Version: 0.85.0.dev3
 Summary: Interactive chart controls for Flet apps.
 Author-email: Flet contributors <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -11,7 +11,7 @@ Project-URL: Issues, https://github.com/flet-dev/flet/issues
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flet==0.85.0.dev2
+Requires-Dist: flet==0.85.0.dev3
 Dynamic: license-file
 
 # flet-charts

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev3}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "flet-charts"
-version = "0.85.0.dev2"
+version = "0.85.0.dev3"
 description = "Interactive chart controls for Flet apps."
 readme = "README.md"
 authors = [{ name = "Flet contributors", email = "hello@flet.dev" }]
 license = "Apache-2.0"
 requires-python = ">=3.10"
 dependencies = [
-    "flet==0.85.0.dev2",
+    "flet==0.85.0.dev3",
 ]
 
 [project.urls]

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev3}/src/flet_charts/__init__.py

@@ -33,6 +33,10 @@ from flet_charts.matplotlib_chart import (
     MatplotlibChartMessageEvent,
     MatplotlibChartToolbarButtonsUpdateEvent,
 )
+from flet_charts.matplotlib_chart_canvas import (
+    MatplotlibChartCanvas,
+    MatplotlibChartCanvasResizeEvent,
+)
 from flet_charts.matplotlib_chart_with_toolbar import MatplotlibChartWithToolbar
 from flet_charts.pie_chart import PieChart, PieChartEvent
 from flet_charts.pie_chart_section import PieChartSection
@@ -95,6 +99,8 @@ __all__ = [
     "LineChartEventSpot",
     "LineChartTooltip",
     "MatplotlibChart",
+    "MatplotlibChartCanvas",
+    "MatplotlibChartCanvasResizeEvent",
     "MatplotlibChartMessageEvent",
     "MatplotlibChartToolbarButtonsUpdateEvent",
     "MatplotlibChartWithToolbar",

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev3}/src/flet_charts/line_chart.py

@@ -59,6 +59,10 @@ class LineChartEvent(ft.Event["LineChart"]):
     spots: list[LineChartEventSpot]
     """
     Spots on which the event occurred.
+
+    Note:
+        This list is empty when the event does not target a concrete point, for
+        example when the pointer hovers over or taps empty chart space.
     """
 
 

flet_charts-0.85.0.dev3/src/flet_charts/matplotlib_backends/backend_flet_agg.py

@@ -0,0 +1,54 @@
+import asyncio
+
+from matplotlib import _api
+from matplotlib.backends import backend_webagg_core
+
+
+class TimerFletAsyncio(backend_webagg_core.TimerAsyncio):
+    """Asyncio timer that's safe to start from a worker thread.
+
+    Matplotlib's stock `TimerAsyncio._timer_start` calls
+    `asyncio.ensure_future`, which requires the calling thread to have a
+    current event loop. Flet's matplotlib chart runs `canvas.draw()` in a
+    worker thread to keep the asyncio loop free for input events; that
+    thread has no event loop. We capture the loop at construction time and
+    schedule via `run_coroutine_threadsafe` when invoked from off-loop.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        try:
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            self._loop = asyncio.get_event_loop_policy().get_event_loop()
+
+    def _timer_start(self):
+        self._timer_stop()
+        coro = self._timer_task(max(self.interval / 1_000.0, 1e-6))
+        try:
+            current = asyncio.get_running_loop()
+        except RuntimeError:
+            current = None
+        if current is self._loop:
+            self._task = self._loop.create_task(coro)
+        else:
+            self._task = asyncio.run_coroutine_threadsafe(coro, self._loop)
+
+
+class FigureCanvasFletAgg(backend_webagg_core.FigureCanvasWebAggCore):
+    """Canvas implementation used to render Matplotlib figures in Flet."""
+
+    manager_class = _api.classproperty(lambda cls: FigureManagerFletAgg)
+    supports_blit = False
+    _timer_cls = TimerFletAsyncio
+
+
+class FigureManagerFletAgg(backend_webagg_core.FigureManagerWebAgg):
+    """Figure manager binding Matplotlib WebAgg tooling to Flet transport."""
+
+    _toolbar2_class = backend_webagg_core.NavigationToolbar2WebAgg
+
+
+FigureCanvas = FigureCanvasFletAgg
+FigureManager = FigureManagerFletAgg
+interactive = True

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev3}/src/flet_charts/matplotlib_chart.py

@@ -1,11 +1,21 @@
 import asyncio
 import logging
+import sys
+import threading
 from dataclasses import dataclass, field
 from io import BytesIO
 from typing import Any, Optional
 
 import flet as ft
-import flet.canvas as fc
+from flet_charts.matplotlib_chart_canvas import (
+    MatplotlibChartCanvas,
+    MatplotlibChartCanvasResizeEvent,
+)
+
+# Pyodide / WASM has no real threads — `asyncio.to_thread` runs synchronously
+# on the same thread there, providing no benefit. Fall back to a same-loop
+# render path on those platforms.
+_HAS_THREADS = sys.platform != "emscripten"
 
 _MATPLOTLIB_IMPORT_ERROR: Optional[ImportError] = None
 
@@ -124,13 +134,21 @@ class MatplotlibChart(ft.GestureDetector):
         logger.debug(f"DPR: {self.__dpr}")
         self.__image_mode = "full"
 
-        self.canvas = fc.Canvas(
-            # resize_interval=10,
+        self.mpl_canvas = MatplotlibChartCanvas(
             on_resize=self._on_canvas_resize,
             expand=True,
         )
+        # Rubberband (zoom selection) overlay drawn on top of the chart image.
+        self._rubberband = ft.Container(
+            visible=False,
+            border=ft.Border.all(1, ft.Colors.with_opacity(0.6, ft.Colors.GREY)),
+        )
+        self._stack = ft.Stack(
+            controls=[self.mpl_canvas, self._rubberband],
+            expand=True,
+        )
         self.keyboard_listener = ft.KeyboardListener(
-            self.canvas,
+            self._stack,
             autofocus=True,
             on_key_down=self._on_key_down,
             on_key_up=self._on_key_up,
@@ -151,6 +169,12 @@ class MatplotlibChart(ft.GestureDetector):
         self._width = 0
         self._height = 0
         self._waiting = False
+        # Serializes worker-thread renders against main-thread matplotlib
+        # operations like `figure.savefig()` (download). matplotlib's
+        # print_figure temporarily nulls `canvas.manager` while saving, which
+        # would crash an in-flight `canvas.draw()` running in our render
+        # thread.
+        self._mpl_lock = threading.Lock()
 
     def _on_key_down(self, e: ft.KeyboardEvent) -> None:
         """
@@ -405,7 +429,8 @@ class MatplotlibChart(ft.GestureDetector):
         """
         logger.debug(f"Download in format: {format}")
         buff = BytesIO()
-        self.figure.savefig(buff, format=format, dpi=self.figure.dpi * self.__dpr)
+        with self._mpl_lock:
+            self.figure.savefig(buff, format=format, dpi=self.figure.dpi * self.__dpr)
         return buff.getvalue()
 
     async def _receive_loop(self):
@@ -419,23 +444,41 @@ class MatplotlibChart(ft.GestureDetector):
 
         while True:
             is_binary, content = await self._receive_queue.get()
+
+            # Coalesce stale items so interaction stays snappy:
+            # - Drop a binary frame if a newer one is queued behind it.
+            # - Drop a "draw" request if another is queued — the latest one
+            #   will trigger the render with the most up-to-date state.
+            # Without this, every pointer event during pan/zoom triggers its
+            # own render and the chart visibly "plays back" buffered motion
+            # after the user releases the mouse.
             if is_binary:
+                if any(it[0] for it in self._receive_queue._queue):
+                    continue
+            elif (
+                isinstance(content, dict)
+                and content.get("type") == "draw"
+                and any(
+                    not it[0]
+                    and isinstance(it[1], dict)
+                    and it[1].get("type") == "draw"
+                    for it in self._receive_queue._queue
+                )
+            ):
+                continue
+
+            if is_binary:
+                assert isinstance(content, (bytes, bytearray))
                 logger.debug(f"receive_binary({len(content)})")
-                if self.__image_mode == "full":
-                    await self.canvas.clear_capture()
-
-                self.canvas.shapes = [
-                    fc.Image(
-                        src=content,
-                        x=0,
-                        y=0,
-                        width=self.figure.bbox.size[0] / self.__dpr,
-                        height=self.figure.bbox.size[1] / self.__dpr,
-                    )
-                ]
-                ft.context.disable_auto_update()
-                self.canvas.update()
-                await self.canvas.capture()
+                is_full = self.__image_mode == "full"
+                # Hand the frame to the client widget — full PNG replaces the
+                # backbuffer, diff PNG composites onto it. Awaiting naturally
+                # rate-limits this loop to the client's processing speed and
+                # yields the asyncio loop for incoming events.
+                if is_full:
+                    await self.mpl_canvas.apply_full(bytes(content))
+                else:
+                    await self.mpl_canvas.apply_diff(bytes(content))
                 self.img_count += 1
                 self._waiting = False
             else:
@@ -447,10 +490,23 @@ class MatplotlibChart(ft.GestureDetector):
                     self.update()
                 elif content["type"] == "draw" and not self._waiting:
                     self._waiting = True
-                    self.send_message({"type": "draw"})
+                    if _HAS_THREADS:
+                        # Native runtime: render in a worker thread so the
+                        # asyncio loop stays free for input events. handle_draw
+                        # ends up in Agg/PIL C code that releases the GIL, so
+                        # threading is effective. _waiting + the queue-dedupe
+                        # above ensure only one render is ever in flight.
+                        # The lock prevents overlap with main-thread savefig.
+                        asyncio.create_task(asyncio.to_thread(self._draw_locked))
+                    else:
+                        # Pyodide / WASM: no real threads available. Render
+                        # synchronously on the loop. Yield first so any
+                        # backed-up pointer events can update matplotlib state
+                        # before the (blocking) render runs.
+                        for _ in range(10):
+                            await asyncio.sleep(0)
+                        self.send_message({"type": "draw"})
                 elif content["type"] == "rubberband":
-                    if len(self.canvas.shapes) == 2:
-                        self.canvas.shapes.pop()
                     if (
                         content["x0"] != -1
                         and content["y0"] != -1
@@ -461,18 +517,14 @@ class MatplotlibChart(ft.GestureDetector):
                         y0 = self._height - content["y0"] / self.__dpr
                         x1 = content["x1"] / self.__dpr
                         y1 = self._height - content["y1"] / self.__dpr
-                        self.canvas.shapes.append(
-                            fc.Rect(
-                                x=x0,
-                                y=y0,
-                                width=x1 - x0,
-                                height=y1 - y0,
-                                paint=ft.Paint(
-                                    stroke_width=1, style=ft.PaintingStyle.STROKE
-                                ),
-                            )
-                        )
-                    self.canvas.update()
+                        self._rubberband.left = min(x0, x1)
+                        self._rubberband.top = min(y0, y1)
+                        self._rubberband.width = abs(x1 - x0)
+                        self._rubberband.height = abs(y1 - y0)
+                        self._rubberband.visible = True
+                    else:
+                        self._rubberband.visible = False
+                    self._rubberband.update()
                 elif content["type"] == "resize":
                     self.send_message({"type": "refresh"})
                 elif content["type"] == "message":
@@ -495,6 +547,16 @@ class MatplotlibChart(ft.GestureDetector):
         if manager is not None:
             manager.handle_json(message)
 
+    def _draw_locked(self):
+        """Worker-thread entry point for triggering a render.
+
+        Holds `_mpl_lock` for the duration of the synchronous draw so it
+        can't overlap with main-thread `figure.savefig()`, which temporarily
+        nulls `canvas.manager` and would crash an in-flight render.
+        """
+        with self._mpl_lock:
+            self.send_message({"type": "draw"})
+
     def send_json(self, content):
         """Sends a JSON message to the front end."""
         logger.debug(f"send_json: {content}")
@@ -508,7 +570,7 @@ class MatplotlibChart(ft.GestureDetector):
             lambda: self._receive_queue.put_nowait((True, blob))
         )
 
-    async def _on_canvas_resize(self, e: fc.CanvasResizeEvent):
+    async def _on_canvas_resize(self, e: MatplotlibChartCanvasResizeEvent):
         """
         Handle canvas resize and initialize backend session on first resize.
 

flet_charts-0.85.0.dev3/src/flet_charts/matplotlib_chart_canvas.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+import flet as ft
+
+__all__ = ["MatplotlibChartCanvas", "MatplotlibChartCanvasResizeEvent"]
+
+
+@dataclass
+class MatplotlibChartCanvasResizeEvent(ft.Event["MatplotlibChartCanvas"]):
+    """
+    Event emitted when the canvas reports a new rendered size.
+    """
+
+    width: float = field(metadata={"data_field": "w"})
+    """New width of the canvas in logical pixels."""
+
+    height: float = field(metadata={"data_field": "h"})
+    """New height of the canvas in logical pixels."""
+
+
+@ft.control("MatplotlibChartCanvas")
+class MatplotlibChartCanvas(ft.LayoutControl):
+    """
+    Display widget for matplotlib WebAgg-style image streams.
+
+    Receives full and incremental "diff" PNG frames and composites them in
+    CPU memory, holding at most one decoded image for display at a time.
+    Avoids the per-frame `Picture.toImage` allocations that the generic
+    `flet.canvas.Canvas` capture path uses, which on Flutter web
+    (CanvasKit/WASM) accumulate and aren't promptly reclaimed by the JS GC
+    during animation, causing browser memory growth.
+    """
+
+    resize_interval: ft.Number = 10
+    """
+    Sampling interval in milliseconds for `on_resize` event.
+    """
+
+    on_resize: Optional[ft.EventHandler[MatplotlibChartCanvasResizeEvent]] = None
+    """
+    Called when the size of this canvas has changed.
+    """
+
+    async def apply_full(self, image_bytes: bytes) -> None:
+        """
+        Replace the current displayed image with a full PNG frame.
+
+        Args:
+            image_bytes: PNG bytes of the complete frame.
+        """
+        await self._invoke_method("apply_full", arguments={"bytes": image_bytes})
+
+    async def apply_diff(self, image_bytes: bytes) -> None:
+        """
+        Composite an incremental "diff" PNG frame onto the current image.
+
+        Pixels with non-zero alpha replace the corresponding pixels in the
+        existing backbuffer; transparent pixels leave the backbuffer
+        unchanged. If no backbuffer exists yet, the diff is treated as a
+        full frame.
+
+        Args:
+            image_bytes: PNG bytes of the diff frame.
+        """
+        await self._invoke_method("apply_diff", arguments={"bytes": image_bytes})
+
+    async def clear(self) -> None:
+        """
+        Clear the displayed image and discard the backbuffer.
+        """
+        await self._invoke_method("clear")

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev3/src/flet_charts.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flet-charts
-Version: 0.85.0.dev2
+Version: 0.85.0.dev3
 Summary: Interactive chart controls for Flet apps.
 Author-email: Flet contributors <hello@flet.dev>
 License-Expression: Apache-2.0
@@ -11,7 +11,7 @@ Project-URL: Issues, https://github.com/flet-dev/flet/issues
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flet==0.85.0.dev2
+Requires-Dist: flet==0.85.0.dev3
 Dynamic: license-file
 
 # flet-charts

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev3}/src/flet_charts.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/flet_charts/line_chart.py
 src/flet_charts/line_chart_data.py
 src/flet_charts/line_chart_data_point.py
 src/flet_charts/matplotlib_chart.py
+src/flet_charts/matplotlib_chart_canvas.py
 src/flet_charts/matplotlib_chart_with_toolbar.py
 src/flet_charts/pie_chart.py
 src/flet_charts/pie_chart_section.py
@@ -34,6 +35,7 @@ src/flutter/flet_charts/lib/src/bar_chart.dart
 src/flutter/flet_charts/lib/src/candlestick_chart.dart
 src/flutter/flet_charts/lib/src/extension.dart
 src/flutter/flet_charts/lib/src/line_chart.dart
+src/flutter/flet_charts/lib/src/matplotlib_chart_canvas.dart
 src/flutter/flet_charts/lib/src/pie_chart.dart
 src/flutter/flet_charts/lib/src/radar_chart.dart
 src/flutter/flet_charts/lib/src/scatter_chart.dart

flet_charts-0.85.0.dev3/src/flet_charts.egg-info/requires.txt

@@ -0,0 +1 @@
+flet==0.85.0.dev3

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev3}/src/flutter/flet_charts/lib/src/extension.dart

@@ -4,6 +4,7 @@ import 'package:flutter/material.dart';
 import 'bar_chart.dart';
 import 'candlestick_chart.dart';
 import 'line_chart.dart';
+import 'matplotlib_chart_canvas.dart';
 import 'radar_chart.dart';
 import 'pie_chart.dart';
 import 'scatter_chart.dart';
@@ -18,6 +19,8 @@ class Extension extends FletExtension {
         return CandlestickChartControl(key: key, control: control);
       case "LineChart":
         return LineChartControl(key: key, control: control);
+      case "MatplotlibChartCanvas":
+        return MatplotlibChartCanvasControl(key: key, control: control);
       case "RadarChart":
         return RadarChartControl(key: key, control: control);
       case "PieChart":

flet_charts-0.85.0.dev3/src/flutter/flet_charts/lib/src/matplotlib_chart_canvas.dart

@@ -0,0 +1,276 @@
+import 'dart:async';
+import 'dart:typed_data';
+import 'dart:ui' as ui;
+
+import 'package:flet/flet.dart';
+import 'package:flutter/material.dart';
+
+/// Display widget for matplotlib WebAgg-style image streams.
+///
+/// Receives full and incremental "diff" PNG frames via control method calls
+/// and composites them in CPU memory. Holds at most one [ui.Image] for
+/// display at a time, replacing it on each apply. This avoids the per-frame
+/// `Picture.toImage` allocations that the generic Canvas+capture path uses,
+/// which on Flutter web (CanvasKit/WASM) accumulate and are not promptly
+/// reclaimed by the JS GC during animations.
+class MatplotlibChartCanvasControl extends StatefulWidget {
+  final Control control;
+
+  MatplotlibChartCanvasControl({Key? key, required this.control})
+      : super(key: key ?? ValueKey("control_${control.id}"));
+
+  @override
+  State<MatplotlibChartCanvasControl> createState() =>
+      _MatplotlibChartCanvasState();
+}
+
+class _MatplotlibChartCanvasState extends State<MatplotlibChartCanvasControl> {
+  ui.Image? _displayImage;
+  Uint8List? _backbuffer;
+  int _bbWidth = 0;
+  int _bbHeight = 0;
+
+  // Serialize concurrent apply_full / apply_diff calls. Each invocation
+  // awaits the previous one so the backbuffer mutations happen in order.
+  Future<void>? _applyChain;
+
+  Size _lastSize = Size.zero;
+  int _lastResize = DateTime.now().millisecondsSinceEpoch;
+
+  @override
+  void initState() {
+    super.initState();
+    widget.control.addInvokeMethodListener(_invokeMethod);
+  }
+
+  @override
+  void dispose() {
+    widget.control.removeInvokeMethodListener(_invokeMethod);
+    _displayImage?.dispose();
+    _displayImage = null;
+    _backbuffer = null;
+    super.dispose();
+  }
+
+  Future<dynamic> _invokeMethod(String name, dynamic args) async {
+    switch (name) {
+      case "apply_full":
+        await _enqueue(() => _applyFull(_extractBytes(args)));
+        return;
+      case "apply_diff":
+        await _enqueue(() => _applyDiff(_extractBytes(args)));
+        return;
+      case "clear":
+        await _enqueue(() async {
+          _disposeDisplay();
+          _backbuffer = null;
+          _bbWidth = 0;
+          _bbHeight = 0;
+          if (mounted) setState(() {});
+        });
+        return;
+      default:
+        throw Exception("Unknown MatplotlibChartCanvas method: $name");
+    }
+  }
+
+  Uint8List _extractBytes(dynamic args) {
+    final v = args is Map ? args["bytes"] : args;
+    if (v is Uint8List) return v;
+    if (v is ByteData) {
+      return v.buffer.asUint8List(v.offsetInBytes, v.lengthInBytes);
+    }
+    if (v is List<int>) return Uint8List.fromList(v);
+    if (v is List && v.every((e) => e is int)) {
+      return Uint8List.fromList(v.cast<int>());
+    }
+    throw ArgumentError("Expected bytes for image data, got ${v.runtimeType}");
+  }
+
+  // Chains apply operations so they run sequentially. Without this,
+  // overlapping awaits could let a later diff be composited before an
+  // earlier full frame finished decoding, producing tearing.
+  Future<void> _enqueue(Future<void> Function() task) {
+    final prev = _applyChain ?? Future.value();
+    final next = prev.then((_) => task());
+    _applyChain = next.catchError((_) {});
+    return next;
+  }
+
+  Future<void> _applyFull(Uint8List bytes) async {
+    final decoded = await _decodeRgba(bytes);
+    if (decoded == null) return;
+
+    _backbuffer = decoded.bytes;
+    _bbWidth = decoded.width;
+    _bbHeight = decoded.height;
+
+    final image = await _makeImage(decoded.bytes, decoded.width, decoded.height);
+    _swapDisplay(image);
+  }
+
+  Future<void> _applyDiff(Uint8List bytes) async {
+    if (_backbuffer == null) {
+      // No baseline yet — treat as full so we don't render a transparent
+      // diff with no underlying frame.
+      await _applyFull(bytes);
+      return;
+    }
+
+    final decoded = await _decodeRgba(bytes);
+    if (decoded == null) return;
+
+    // Diffs from matplotlib are sized to the figure buffer. If the frame
+    // size has changed since the last full frame (e.g. resize race),
+    // promote to a full replace.
+    if (decoded.width != _bbWidth ||
+        decoded.height != _bbHeight ||
+        decoded.bytes.length != _backbuffer!.length) {
+      _backbuffer = decoded.bytes;
+      _bbWidth = decoded.width;
+      _bbHeight = decoded.height;
+      final image =
+          await _makeImage(decoded.bytes, decoded.width, decoded.height);
+      _swapDisplay(image);
+      return;
+    }
+
+    // Composite: matplotlib's diff PNG has alpha=0 for unchanged pixels.
+    // Where alpha != 0, copy the new pixel into the backbuffer.
+    final bb = _backbuffer!.buffer.asUint32List();
+    final df = decoded.bytes.buffer.asUint32List();
+    for (int i = 0; i < df.length; i++) {
+      // RGBA8888 on little-endian: alpha is the highest byte (0xFF000000).
+      if ((df[i] & 0xFF000000) != 0) {
+        bb[i] = df[i];
+      }
+    }
+
+    final image = await _makeImage(_backbuffer!, _bbWidth, _bbHeight);
+    _swapDisplay(image);
+  }
+
+  Future<_DecodedRgba?> _decodeRgba(Uint8List bytes) async {
+    if (bytes.isEmpty) {
+      debugPrint("MatplotlibChartCanvas: skipping empty image bytes");
+      return null;
+    }
+    // Take a defensive copy. msgpack_dart sometimes hands us a Uint8List
+    // backed by a buffer that's reused/freed by Safari's WASM runtime,
+    // causing CanvasKit's async decoder to throw "EncodingError: Loading
+    // error." after the original buffer is gone.
+    final owned = Uint8List.fromList(bytes);
+    ui.Codec? codec;
+    ui.Image? img;
+    try {
+      codec = await ui.instantiateImageCodec(owned, allowUpscaling: false);
+      final frame = await codec.getNextFrame();
+      img = frame.image;
+      final byteData =
+          await img.toByteData(format: ui.ImageByteFormat.rawRgba);
+      if (byteData == null) return null;
+      return _DecodedRgba(
+        bytes: byteData.buffer.asUint8List(),
+        width: img.width,
+        height: img.height,
+      );
+    } catch (e) {
+      debugPrint(
+          "MatplotlibChartCanvas: decode failed (${owned.length} bytes): $e");
+      rethrow;
+    } finally {
+      img?.dispose();
+      codec?.dispose();
+    }
+  }
+
+  Future<ui.Image> _makeImage(Uint8List rgba, int width, int height) {
+    final completer = Completer<ui.Image>();
+    ui.decodeImageFromPixels(
+      rgba,
+      width,
+      height,
+      ui.PixelFormat.rgba8888,
+      completer.complete,
+    );
+    return completer.future;
+  }
+
+  void _swapDisplay(ui.Image newImage) {
+    final old = _displayImage;
+    _displayImage = newImage;
+    if (mounted) setState(() {});
+    if (old != null) {
+      // Defer disposal to the next frame so any in-flight paint that still
+      // references the old image completes first.
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        old.dispose();
+      });
+    }
+  }
+
+  void _disposeDisplay() {
+    final old = _displayImage;
+    _displayImage = null;
+    if (old != null) {
+      WidgetsBinding.instance.addPostFrameCallback((_) {
+        old.dispose();
+      });
+    }
+  }
+
+  void _maybeReportResize(Size size) {
+    final resizeInterval = widget.control.getInt("resize_interval", 10)!;
+    final now = DateTime.now().millisecondsSinceEpoch;
+    if ((now - _lastResize > resizeInterval && _lastSize != size) ||
+        _lastSize.isEmpty) {
+      _lastSize = size;
+      _lastResize = now;
+      widget.control.triggerEvent("resize", {"w": size.width, "h": size.height});
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return LayoutBuilder(
+      builder: (context, constraints) {
+        // Fire on_resize on layout. matplotlib uses this to know the target
+        // figure size.
+        WidgetsBinding.instance.addPostFrameCallback((_) {
+          if (!mounted) return;
+          _maybeReportResize(constraints.biggest);
+        });
+        return CustomPaint(
+          size: constraints.biggest,
+          painter: _MatplotlibImagePainter(_displayImage),
+        );
+      },
+    );
+  }
+}
+
+class _DecodedRgba {
+  final Uint8List bytes;
+  final int width;
+  final int height;
+  _DecodedRgba({required this.bytes, required this.width, required this.height});
+}
+
+class _MatplotlibImagePainter extends CustomPainter {
+  final ui.Image? image;
+
+  _MatplotlibImagePainter(this.image);
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    final img = image;
+    if (img == null) return;
+    final src =
+        Rect.fromLTWH(0, 0, img.width.toDouble(), img.height.toDouble());
+    final dst = Rect.fromLTWH(0, 0, size.width, size.height);
+    canvas.drawImageRect(img, src, dst, Paint());
+  }
+
+  @override
+  bool shouldRepaint(_MatplotlibImagePainter old) => old.image != image;
+}

{flet_charts-0.85.0.dev2 → flet_charts-0.85.0.dev3}/src/flutter/flet_charts/lib/src/utils/line_chart.dart

@@ -25,7 +25,7 @@ class LineChartEventData extends Equatable {
 
   Map<String, dynamic> toMap() => <String, dynamic>{
         'type': eventType,
-        'spots': barSpots,
+        'spots': barSpots.map((spot) => spot.toMap()).toList(),
       };
 
   @override

flet_charts-0.85.0.dev2/src/flet_charts/matplotlib_backends/backend_flet_agg.py

@@ -1,20 +0,0 @@
-from matplotlib import _api
-from matplotlib.backends import backend_webagg_core
-
-
-class FigureCanvasFletAgg(backend_webagg_core.FigureCanvasWebAggCore):
-    """Canvas implementation used to render Matplotlib figures in Flet."""
-
-    manager_class = _api.classproperty(lambda cls: FigureManagerFletAgg)
-    supports_blit = False
-
-
-class FigureManagerFletAgg(backend_webagg_core.FigureManagerWebAgg):
-    """Figure manager binding Matplotlib WebAgg tooling to Flet transport."""
-
-    _toolbar2_class = backend_webagg_core.NavigationToolbar2WebAgg
-
-
-FigureCanvas = FigureCanvasFletAgg
-FigureManager = FigureManagerFletAgg
-interactive = True

flet_charts-0.85.0.dev2/src/flet_charts.egg-info/requires.txt

@@ -1 +0,0 @@
-flet==0.85.0.dev2