flet-map 0.1.0.dev2__py3-none-any.whl → 0.2.0.dev45__py3-none-any.whl

flet_map/map.py

@@ -1,674 +1,532 @@
-import json
-from dataclasses import dataclass
-from enum import Enum, EnumMeta, IntFlag
-from typing import Any, List, Optional, Tuple, Union
-from warnings import warn
-
-from flet.core.animation import AnimationCurve, AnimationValue
-from flet.core.badge import BadgeValue
-from flet.core.constrained_control import ConstrainedControl
-from flet.core.control import OptionalNumber
-from flet.core.event_handler import EventHandler
-from flet_map.map_layer import MapLayer
-from flet.core.ref import Ref
-from flet.core.tooltip import TooltipValue
-from flet.core.transform import Offset
-from flet.core.types import (
-    ColorEnums,
-    ColorValue,
-    ControlEvent,
-    DurationValue,
-    Number,
-    OffsetValue,
-    OptionalControlEventCallable,
-    OptionalEventCallable,
-    ResponsiveNumber,
-    RotateValue,
-    ScaleValue,
+import asyncio
+from dataclasses import field
+from typing import Optional
+
+import flet as ft
+
+from .map_layer import MapLayer
+from .types import (
+    CameraFit,
+    InteractionConfiguration,
+    MapEvent,
+    MapHoverEvent,
+    MapLatitudeLongitude,
+    MapPointerEvent,
+    MapPositionChangeEvent,
+    MapTapEvent,
 )
 
+__all__ = ["Map"]
 
-@dataclass
-class MapLatitudeLongitude:
-    latitude: Union[float, int]
-    longitude: Union[float, int]
-
-
-@dataclass
-class MapLatitudeLongitudeBounds:
-    corner_1: MapLatitudeLongitude
-    corner_2: MapLatitudeLongitude
-
-
-class MapInteractiveFlag(IntFlag):
-    NONE = 0
-    DRAG = 1 << 0
-    FLING_ANIMATION = 1 << 1
-    PINCH_MOVE = 1 << 2
-    PINCH_ZOOM = 1 << 3
-    DOUBLE_TAP_ZOOM = 1 << 4
-    DOUBLE_TAP_DRAG_ZOOM = 1 << 5
-    SCROLL_WHEEL_ZOOM = 1 << 6
-    ROTATE = 1 << 7
-    ALL = (
-        (1 << 0)
-        | (1 << 1)
-        | (1 << 2)
-        | (1 << 3)
-        | (1 << 4)
-        | (1 << 5)
-        | (1 << 6)
-        | (1 << 7)
+
+@ft.control("Map")
+class Map(ft.ConstrainedControl):
+    """
+    An interactive map control that allows displaying various layers.
+    """
+
+    layers: list[MapLayer]
+    """
+    A list of layers to be displayed (stack-like) on the map.
+
+    Value is of type [`MapLayer`][(p).].
+    """
+
+    initial_center: MapLatitudeLongitude = field(
+        default_factory=lambda: MapLatitudeLongitude(latitude=50.5, longitude=30.51)
     )
+    """
+    The initial center of the map.
 
+    Value is of type `MapLatitudeLongitude`.
+    """
 
-class MapMultiFingerGesture(IntFlag):
-    NONE = 0
-    PINCH_MOVE = 1 << 0
-    PINCH_ZOOM = 1 << 1
-    ROTATE = 1 << 2
-    ALL = (1 << 0) | (1 << 1) | (1 << 2)
-
-
-class MapPointerDeviceTypeDeprecated(EnumMeta):
-    def __getattribute__(self, item):
-        if item in [
-            "TOUCH",
-            "MOUSE",
-            "STYLUS",
-            "INVERTED_STYLUS",
-            "TRACKPAD",
-            "UNKNOWN",
-        ]:
-            warn(
-                "MapPointerDeviceType enum is deprecated since version 0.25.0 "
-                "and will be removed in version 0.28.0. Use PointerDeviceType enum instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-        return EnumMeta.__getattribute__(self, item)
+    initial_rotation: ft.Number = 0.0
+    """
+    The rotation (in degrees) when the map is first loaded.
+    """
+
+    initial_zoom: ft.Number = 13.0
+    """
+    The zoom when the map is first loaded. 
+    If initial_camera_fit is defined this has no effect.
+    """
+
+    interaction_configuration: InteractionConfiguration = field(
+        default_factory=lambda: InteractionConfiguration()
+    )
+    """
+    The interaction configuration.
+    """
+
+    bgcolor: ft.ColorValue = ft.Colors.GREY_300
+    """
+    The background color of this control.
+    """
+
+    keep_alive: bool = False
+    """
+    Whether to enable the built in keep-alive functionality.
+    
+    If the map is within a complex layout, such as a `ListView`,
+    the map will reset to it's inital position after it appears back into view.
+    To ensure this doesn't happen, enable this flag to prevent it from rebuilding.
+    """
+
+    max_zoom: Optional[ft.Number] = None
+    """
+    The maximum (highest) zoom level of every layer. 
+    Each layer can specify additional zoom level restrictions.
+    """
 
+    min_zoom: Optional[ft.Number] = None
+    """
+    The minimum (smallest) zoom level of every layer. 
+    Each layer can specify additional zoom level restrictions.
+    """
 
-class MapPointerDeviceType(Enum, metaclass=MapPointerDeviceTypeDeprecated):
-    TOUCH = "touch"
-    MOUSE = "mouse"
-    STYLUS = "stylus"
-    INVERTED_STYLUS = "invertedStylus"
-    TRACKPAD = "trackpad"
-    UNKNOWN = "unknown"
+    animation_curve: ft.AnimationCurve = ft.AnimationCurve.FAST_OUT_SLOWIN
+    """
+    The default animation curve to be used for map-animations 
+    when calling instance methods like `zoom_in()`, `rotate_from()`, `move_to()` etc.
+    """
 
+    animation_duration: ft.DurationValue = field(
+        default_factory=lambda: ft.Duration(milliseconds=500)
+    )
+    """
+    The default animation duration to be used for map-animations 
+    when calling instance methods like `zoom_in()`, `rotate_from()`, `move_to()` etc.
+    """
 
-@dataclass
-class MapInteractionConfiguration:
-    enable_multi_finger_gesture_race: Optional[bool] = None
-    pinch_move_threshold: OptionalNumber = None
-    scroll_wheel_velocity: OptionalNumber = None
-    pinch_zoom_threshold: OptionalNumber = None
-    rotation_threshold: OptionalNumber = None
-    flags: Optional[MapInteractiveFlag] = None
-    rotation_win_gestures: Optional[MapMultiFingerGesture] = None
-    pinch_move_win_gestures: Optional[MapMultiFingerGesture] = None
-    pinch_zoom_win_gestures: Optional[MapMultiFingerGesture] = None
+    initial_camera_fit: Optional[CameraFit] = None
+    """
+    Defines the visible bounds when the map is first loaded. 
+    Takes precedence over `initial_center`/`initial_zoom`.
+    """
 
+    on_init: ft.OptionalControlEventHandler["Map"] = None
+    """
+    Fires when the map is initialized.
+    """
 
-class Map(ConstrainedControl):
+    on_tap: ft.OptionalEventHandler[MapTapEvent["Map"]] = None
     """
-    Map Control.
+    Fires when a tap event occurs.
 
-    -----
+    Event handler argument is of type [`MapTapEvent`][(p).].
+    """
 
-    Online docs: https://flet.dev/docs/controls/map
+    on_hover: ft.OptionalEventHandler[MapHoverEvent["Map"]] = None
     """
+    Fires when a hover event occurs.
 
-    def __init__(
-        self,
-        layers: List[MapLayer],
-        initial_center: Optional[MapLatitudeLongitude] = None,
-        initial_rotation: OptionalNumber = None,
-        initial_zoom: OptionalNumber = None,
-        interaction_configuration: Optional[MapInteractionConfiguration] = None,
-        bgcolor: Optional[ColorValue] = None,
-        keep_alive: Optional[bool] = None,
-        max_zoom: OptionalNumber = None,
-        min_zoom: OptionalNumber = None,
-        animation_curve: Optional[AnimationCurve] = None,
-        animation_duration: DurationValue = None,
-        on_init: OptionalControlEventCallable = None,
-        on_tap: OptionalEventCallable["MapTapEvent"] = None,
-        on_hover: OptionalEventCallable["MapHoverEvent"] = None,
-        on_secondary_tap: OptionalEventCallable["MapTapEvent"] = None,
-        on_long_press: OptionalEventCallable["MapTapEvent"] = None,
-        on_event: OptionalEventCallable["MapEvent"] = None,
-        on_position_change: OptionalEventCallable["MapPositionChangeEvent"] = None,
-        on_pointer_down: OptionalEventCallable["MapPointerEvent"] = None,
-        on_pointer_cancel: OptionalEventCallable["MapPointerEvent"] = None,
-        on_pointer_up: OptionalEventCallable["MapPointerEvent"] = None,
-        #
-        # ConstrainedControl
-        #
-        ref: Optional[Ref] = None,
-        key: Optional[str] = None,
-        width: OptionalNumber = None,
-        height: OptionalNumber = None,
-        left: OptionalNumber = None,
-        top: OptionalNumber = None,
-        right: OptionalNumber = None,
-        bottom: OptionalNumber = None,
-        expand: Union[None, bool, int] = None,
-        expand_loose: Optional[bool] = None,
-        col: Optional[ResponsiveNumber] = None,
-        opacity: OptionalNumber = None,
-        rotate: RotateValue = None,
-        scale: ScaleValue = None,
-        offset: OffsetValue = None,
-        aspect_ratio: OptionalNumber = None,
-        animate_opacity: Optional[AnimationValue] = None,
-        animate_size: Optional[AnimationValue] = None,
-        animate_position: Optional[AnimationValue] = None,
-        animate_rotation: Optional[AnimationValue] = None,
-        animate_scale: Optional[AnimationValue] = None,
-        animate_offset: Optional[AnimationValue] = None,
-        on_animation_end: OptionalControlEventCallable = None,
-        tooltip: TooltipValue = None,
-        badge: Optional[BadgeValue] = None,
-        visible: Optional[bool] = None,
-        disabled: Optional[bool] = None,
-        data: Any = None,
-    ):
-        ConstrainedControl.__init__(
-            self,
-            ref=ref,
-            key=key,
-            width=width,
-            height=height,
-            left=left,
-            top=top,
-            right=right,
-            bottom=bottom,
-            expand=expand,
-            expand_loose=expand_loose,
-            col=col,
-            opacity=opacity,
-            rotate=rotate,
-            scale=scale,
-            offset=offset,
-            aspect_ratio=aspect_ratio,
-            animate_opacity=animate_opacity,
-            animate_size=animate_size,
-            animate_position=animate_position,
-            animate_rotation=animate_rotation,
-            animate_scale=animate_scale,
-            animate_offset=animate_offset,
-            on_animation_end=on_animation_end,
-            tooltip=tooltip,
-            badge=badge,
-            visible=visible,
-            disabled=disabled,
-            data=data,
-        )
-        self.__on_tap = EventHandler(lambda e: MapTapEvent(e))
-        self._add_event_handler("tap", self.__on_tap.get_handler())
+    Event handler argument is of type [`MapHoverEvent`][(p).].
+    """
 
-        self.__on_hover = EventHandler(lambda e: MapHoverEvent(e))
-        self._add_event_handler("hover", self.__on_hover.get_handler())
+    on_secondary_tap: ft.OptionalEventHandler[MapTapEvent["Map"]] = None
+    """
+    Fires when a secondary tap event occurs.
 
-        self.__on_secondary_tap = EventHandler(lambda e: MapTapEvent(e))
-        self._add_event_handler("secondary_tap", self.__on_secondary_tap.get_handler())
+    Event handler argument is of type [`MapTapEvent`][(p).].
+    """
 
-        self.__on_long_press = EventHandler(lambda e: MapTapEvent(e))
-        self._add_event_handler("long_press", self.__on_long_press.get_handler())
+    on_long_press: ft.OptionalEventHandler[MapTapEvent["Map"]] = None
+    """
+    Fires when a long press event occurs.
 
-        self.__on_event = EventHandler(lambda e: MapEvent(e))
-        self._add_event_handler("event", self.__on_event.get_handler())
+    Event handler argument is of type [`MapTapEvent`][(p).].
+    """
 
-        self.__on_position_change = EventHandler(lambda e: MapPositionChangeEvent(e))
-        self._add_event_handler(
-            "position_change", self.__on_position_change.get_handler()
-        )
+    on_event: ft.OptionalEventHandler[MapEvent["Map"]] = None
+    """
+    Fires when any map events occurs.
+
+    Event handler argument is of type [`MapEvent`][(p).].
+    """
 
-        self.__on_pointer_down = EventHandler(lambda e: MapPointerEvent(e))
-        self._add_event_handler("pointer_down", self.__on_pointer_down.get_handler())
+    on_position_change: ft.OptionalEventHandler[MapPositionChangeEvent["Map"]] = None
+    """
+    Fires when the map position changes.
 
-        self.__on_pointer_cancel = EventHandler(lambda e: MapPointerEvent(e))
-        self._add_event_handler(
-            "pointer_cancel", self.__on_pointer_cancel.get_handler()
-        )
+    Event handler argument is of type [`MapPositionChangeEvent`][(p).].
+    """
 
-        self.__on_pointer_up = EventHandler(lambda e: MapPointerEvent(e))
-        self._add_event_handler("pointer_up", self.__on_pointer_up.get_handler())
-
-        self.layers = layers
-        self.initial_center = initial_center
-        self.initial_rotation = initial_rotation
-        self.initial_zoom = initial_zoom
-        self.interaction_configuration = interaction_configuration
-        self.bgcolor = bgcolor
-        self.keep_alive = keep_alive
-        self.max_zoom = max_zoom
-        self.min_zoom = min_zoom
-        self.animation_curve = animation_curve
-        self.animation_duration = animation_duration
-        self.on_tap = on_tap
-        self.on_hover = on_hover
-        self.on_secondary_tap = on_secondary_tap
-        self.on_init = on_init
-        self.on_long_press = on_long_press
-        self.on_event = on_event
-        self.on_position_change = on_position_change
-        self.on_pointer_down = on_pointer_down
-        self.on_pointer_cancel = on_pointer_cancel
-        self.on_pointer_up = on_pointer_up
-
-    def before_update(self):
-        self._set_attr_json("initialCenter", self.__initial_center)
-        self._set_attr_json("animationDuration", self.__animation_duration)
-        self._set_attr_json(
-            "interactionConfiguration", self.__interaction_configuration
+    on_pointer_down: ft.OptionalEventHandler[MapPointerEvent["Map"]] = None
+    """
+    Fires when a pointer down event occurs.
+
+    Event handler argument is of type [`MapPointerEvent`][(p).].
+    """
+
+    on_pointer_cancel: ft.OptionalEventHandler[MapPointerEvent["Map"]] = None
+    """
+    Fires when a pointer cancel event occurs.
+    
+    Event handler argument is of type [`MapPointerEvent`][(p).].
+    """
+
+    on_pointer_up: ft.OptionalEventHandler[MapPointerEvent["Map"]] = None
+    """
+    Fires when a pointer up event occurs.
+
+    Event handler argument is of type [`MapPointerEvent`][(p).].
+    """
+
+    async def rotate_from_async(
+        self,
+        degree: ft.Number,
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Applies a rotation of `degree` to the current rotation.
+
+        Args:
+            degree: The number of degrees to increment to the current rotation.
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        await self._invoke_method_async(
+            method_name="rotate_from",
+            arguments={
+                "degree": degree,
+                "curve": animation_curve or self.animation_curve,
+                "duration": animation_duration or self.animation_duration,
+                "cancel_ongoing_animations": cancel_ongoing_animations,
+            },
         )
 
     def rotate_from(
         self,
-        degree: Number,
-        animation_curve: Optional[AnimationCurve] = None,
-    ):
-        self.invoke_method(
-            "rotate_from",
+        degree: ft.Number,
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Applies a rotation of `degree` to the current rotation.
+
+        Args:
+            degree: The number of degrees to increment to the current rotation.
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        asyncio.create_task(
+            self.rotate_from_async(
+                degree, animation_curve, animation_duration, cancel_ongoing_animations
+            )
+        )
+
+    async def reset_rotation_async(
+        self,
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Resets the map's rotation to 0 degrees.
+
+        Args:
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        await self._invoke_method_async(
+            method_name="reset_rotation",
             arguments={
-                "degree": degree,
-                "curve": animation_curve.value if animation_curve else None,
+                "curve": animation_curve or self.animation_curve,
+                "duration": animation_duration or self.animation_duration,
+                "cancel_ongoing_animations": cancel_ongoing_animations,
             },
         )
 
     def reset_rotation(
         self,
-        animation_curve: Optional[AnimationCurve] = None,
-        animation_duration: DurationValue = None,
-    ):
-        self.invoke_method(
-            "reset_rotation",
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: ft.DurationValue = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Resets the map's rotation to 0 degrees.
+
+        Args:
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        asyncio.create_task(
+            self.reset_rotation_async(
+                animation_curve, animation_duration, cancel_ongoing_animations
+            )
+        )
+
+    async def zoom_in_async(
+        self,
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Zooms in by one zoom-level from the current one.
+
+        Args:
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        await self._invoke_method_async(
+            method_name="zoom_in",
             arguments={
-                "curve": animation_curve.value if animation_curve else None,
-                "duration": self._convert_attr_json(animation_duration),
+                "curve": animation_curve or self.animation_curve,
+                "duration": animation_duration or self.animation_duration,
+                "cancel_ongoing_animations": cancel_ongoing_animations,
             },
         )
 
     def zoom_in(
         self,
-        animation_curve: Optional[AnimationCurve] = None,
-        animation_duration: DurationValue = None,
-    ):
-        self.invoke_method(
-            "zoom_in",
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Zooms in by one zoom-level from the current one.
+
+        Args:
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        asyncio.create_task(
+            self.zoom_in_async(
+                animation_curve, animation_duration, cancel_ongoing_animations
+            )
+        )
+
+    async def zoom_out_async(
+        self,
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Zooms out by one zoom-level from the current one.
+
+        Args:
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        await self._invoke_method_async(
+            method_name="zoom_out",
             arguments={
-                "curve": animation_curve.value if animation_curve else None,
-                "duration": self._convert_attr_json(animation_duration),
+                "curve": animation_curve or self.animation_curve,
+                "duration": animation_duration or self.animation_duration,
+                "cancel_ongoing_animations": cancel_ongoing_animations,
             },
         )
 
     def zoom_out(
         self,
-        animation_curve: Optional[AnimationCurve] = None,
-        animation_duration: DurationValue = None,
-    ):
-        self.invoke_method(
-            "zoom_out",
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Zooms out by one zoom-level from the current one.
+
+        Args:
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        asyncio.create_task(
+            self.zoom_out_async(
+                animation_curve, animation_duration, cancel_ongoing_animations
+            )
+        )
+
+    async def zoom_to_async(
+        self,
+        zoom: ft.Number,
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Zoom the map to a specific zoom level.
+
+        Args:
+            zoom: The zoom level to zoom to.
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        await self._invoke_method_async(
+            method_name="zoom_to",
             arguments={
-                "curve": animation_curve.value if animation_curve else None,
-                "duration": self._convert_attr_json(animation_duration),
+                "zoom": zoom,
+                "curve": animation_curve or self.animation_curve,
+                "duration": animation_duration or self.animation_duration,
+                "cancel_ongoing_animations": cancel_ongoing_animations,
             },
         )
 
     def zoom_to(
         self,
-        zoom: Number,
-        animation_curve: Optional[AnimationCurve] = None,
-        animation_duration: DurationValue = None,
-    ):
-        self.invoke_method(
-            "zoom_to",
+        zoom: ft.Number,
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Zoom the map to a specific zoom level.
+
+        Args:
+            zoom: The zoom level to zoom to.
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        asyncio.create_task(
+            self.zoom_to_async(
+                zoom, animation_curve, animation_duration, cancel_ongoing_animations
+            )
+        )
+
+    async def move_to_async(
+        self,
+        destination: Optional[MapLatitudeLongitude] = None,
+        zoom: Optional[ft.Number] = None,
+        rotation: Optional[ft.Number] = None,
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        offset: ft.OffsetValue = ft.Offset(0, 0),
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Moves to a specific location.
+
+        Args:
+            destination: The destination point to move to.
+            zoom: The zoom level to be applied. If provided, must be greater than or equal to `0.0`.
+            rotation: Rotation (in degrees) to be applied.
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            offset: The offset to be used. Only works when `rotation` is `None`.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+
+        Raises:
+            AssertionError: If `zoom` is not `None` and is negative.
+        """
+        assert zoom is None or zoom >= 0, "zoom must be greater than or equal to zero"
+        await self._invoke_method_async(
+            method_name="move_to",
             arguments={
+                "destination": destination,
                 "zoom": zoom,
-                "curve": animation_curve.value if animation_curve else None,
-                "duration": self._convert_attr_json(animation_duration),
+                "offset": offset,
+                "rotation": rotation,
+                "curve": animation_curve or self.animation_curve,
+                "duration": animation_duration or self.animation_duration,
+                "cancel_ongoing_animations": cancel_ongoing_animations,
             },
         )
 
     def move_to(
         self,
         destination: Optional[MapLatitudeLongitude] = None,
-        zoom: OptionalNumber = None,
-        rotation: OptionalNumber = None,
-        animation_curve: Optional[AnimationCurve] = None,
-        animation_duration: DurationValue = None,
-        offset: Optional[Union[Offset, Tuple[Union[Number], Union[Number]]]] = None,
-    ):
-        if isinstance(offset, tuple):
-            offset = Offset(offset[0], offset[1])
-        self.invoke_method(
-            "move_to",
-            arguments={
-                "lat": str(destination.latitude) if destination else None,
-                "long": str(destination.longitude) if destination else None,
-                "zoom": zoom,
-                "ox": str(offset.x) if offset else None,
-                "oy": str(offset.y) if offset else None,
-                "rot": rotation,
-                "curve": animation_curve.value if animation_curve else None,
-                "duration": self._convert_attr_json(animation_duration),
-            },
+        zoom: Optional[ft.Number] = None,
+        rotation: Optional[ft.Number] = None,
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        offset: ft.OffsetValue = ft.Offset(0, 0),
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Moves to a specific location.
+
+        Args:
+            destination: The destination point to move to.
+            zoom: The zoom level to be applied. If provided, must be greater than or equal to `0.0`.
+            rotation: Rotation (in degrees) to be applied.
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            offset: The offset to be used. Only works when `rotation` is `None`.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+
+        Raises:
+            AssertionError: If `zoom` is not `None` and is negative.
+        """
+        asyncio.create_task(
+            self.move_to_async(
+                destination,
+                zoom,
+                rotation,
+                animation_curve,
+                animation_duration,
+                offset,
+                cancel_ongoing_animations,
+            )
         )
 
-    def center_on(
+    async def center_on_async(
         self,
-        point: Optional[MapLatitudeLongitude],
-        zoom: OptionalNumber,
-        animation_curve: Optional[AnimationCurve] = None,
-        animation_duration: DurationValue = None,
-    ):
-        self.invoke_method(
-            "center_on",
+        point: MapLatitudeLongitude,
+        zoom: Optional[ft.Number],
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Centers the map on the given point.
+
+        Args:
+            point: The point on which to center the map.
+            zoom: The zoom level to be applied.
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        await self._invoke_method_async(
+            method_name="center_on",
             arguments={
-                "lat": str(point.latitude) if point else None,
-                "long": str(point.longitude) if point else None,
+                "point": point,
                 "zoom": zoom,
-                "curve": animation_curve.value if animation_curve else None,
-                "duration": self._convert_attr_json(animation_duration),
+                "curve": animation_curve or self.animation_curve,
+                "duration": animation_duration or self.animation_duration,
+                "cancel_ongoing_animations": cancel_ongoing_animations,
             },
         )
 
-    def _get_control_name(self):
-        return "map"
-
-    def _get_children(self):
-        return self.__layers
-
-    # layers
-    @property
-    def layers(self) -> List[MapLayer]:
-        return self.__layers
-
-    @layers.setter
-    def layers(self, value: List[MapLayer]):
-        self.__layers = value
-
-    # initial_center
-    @property
-    def initial_center(self) -> Optional[MapLatitudeLongitude]:
-        return self.__initial_center
-
-    @initial_center.setter
-    def initial_center(self, value: Optional[MapLatitudeLongitude]):
-        self.__initial_center = value
-
-    # initial_rotation
-    @property
-    def initial_rotation(self) -> OptionalNumber:
-        return self._get_attr("initialRotation", data_type="float")
-
-    @initial_rotation.setter
-    def initial_rotation(self, value: OptionalNumber):
-        self._set_attr("initialRotation", value)
-
-    # initial_zoom
-    @property
-    def initial_zoom(self) -> OptionalNumber:
-        return self._get_attr("initialZoom", data_type="float")
-
-    @initial_zoom.setter
-    def initial_zoom(self, value: OptionalNumber):
-        self._set_attr("initialZoom", value)
-
-    # interaction_configuration
-    @property
-    def interaction_configuration(self) -> Optional[MapInteractionConfiguration]:
-        return self.__interaction_configuration
-
-    @interaction_configuration.setter
-    def interaction_configuration(self, value: Optional[MapInteractionConfiguration]):
-        self.__interaction_configuration = value
-
-    # bgcolor
-    @property
-    def bgcolor(self) -> Optional[ColorValue]:
-        return self.__bgcolor
-
-    @bgcolor.setter
-    def bgcolor(self, value: Optional[ColorValue]):
-        self.__bgcolor = value
-        self._set_enum_attr("bgcolor", value, ColorEnums)
-
-    # keep_alive
-    @property
-    def keep_alive(self) -> Optional[bool]:
-        return self._get_attr("keepAlive", data_type="bool")
-
-    @keep_alive.setter
-    def keep_alive(self, value: Optional[bool]):
-        self._set_attr("keepAlive", value)
-
-    # max_zoom
-    @property
-    def max_zoom(self) -> OptionalNumber:
-        return self._get_attr("maxZoom", data_type="float")
-
-    @max_zoom.setter
-    def max_zoom(self, value: OptionalNumber):
-        self._set_attr("maxZoom", value)
-
-    # min_zoom
-    @property
-    def min_zoom(self) -> OptionalNumber:
-        return self._get_attr("minZoom", data_type="float")
-
-    @min_zoom.setter
-    def min_zoom(self, value: OptionalNumber):
-        self._set_attr("minZoom", value)
-
-    # animation_curve
-    @property
-    def animation_curve(self) -> Optional[AnimationCurve]:
-        return self.__animation_curve
-
-    @animation_curve.setter
-    def animation_curve(self, value: Optional[AnimationCurve]):
-        self.__animation_curve = value
-        self._set_enum_attr("animationCurve", value, AnimationCurve)
-
-    # animation_duration
-    @property
-    def animation_duration(self) -> Optional[DurationValue]:
-        return self.__animation_duration
-
-    @animation_duration.setter
-    def animation_duration(self, value: Optional[DurationValue]):
-        self.__animation_duration = value
-
-    # on_tap
-    @property
-    def on_tap(self) -> OptionalEventCallable["MapTapEvent"]:
-        return self.__on_tap.handler
-
-    @on_tap.setter
-    def on_tap(self, handler: OptionalEventCallable["MapTapEvent"]):
-        self.__on_tap.handler = handler
-        self._set_attr("onTap", True if handler is not None else None)
-
-    # on_hover
-    @property
-    def on_hover(self) -> OptionalEventCallable["MapHoverEvent"]:
-        return self.__on_hover.handler
-
-    @on_hover.setter
-    def on_hover(self, handler: OptionalEventCallable["MapHoverEvent"]):
-        self.__on_hover.handler = handler
-        self._set_attr("onHover", True if handler is not None else None)
-
-    # on_secondary_tap
-    @property
-    def on_secondary_tap(self) -> OptionalEventCallable["MapTapEvent"]:
-        return self.__on_secondary_tap.handler
-
-    @on_secondary_tap.setter
-    def on_secondary_tap(self, handler: OptionalEventCallable["MapTapEvent"]):
-        self.__on_secondary_tap.handler = handler
-        self._set_attr("onSecondaryTap", True if handler is not None else None)
-
-    # on_long_press
-    @property
-    def on_long_press(self) -> OptionalEventCallable["MapTapEvent"]:
-        return self.__on_long_press.handler
-
-    @on_long_press.setter
-    def on_long_press(self, handler: OptionalEventCallable["MapTapEvent"]):
-        self.__on_long_press.handler = handler
-        self._set_attr("onLongPress", True if handler is not None else None)
-
-    # on_event
-    @property
-    def on_event(self) -> OptionalEventCallable["MapEvent"]:
-        return self.__on_event.handler
-
-    @on_event.setter
-    def on_event(self, handler: OptionalEventCallable["MapEvent"]):
-        self.__on_event.handler = handler
-        self._set_attr("onEvent", True if handler is not None else None)
-
-    # on_init
-    @property
-    def on_init(self) -> OptionalControlEventCallable:
-        return self._get_event_handler("init")
-
-    @on_init.setter
-    def on_init(self, handler: OptionalControlEventCallable):
-        self._add_event_handler("init", handler)
-        self._set_attr("onInit", True if handler is not None else None)
-
-    # on_position_change
-    @property
-    def on_position_change(self) -> OptionalEventCallable["MapPositionChangeEvent"]:
-        return self.__on_position_change.handler
-
-    @on_position_change.setter
-    def on_position_change(
-        self, handler: OptionalEventCallable["MapPositionChangeEvent"]
-    ):
-        self.__on_position_change.handler = handler
-        self._set_attr("onPositionChange", True if handler is not None else None)
-
-    # on_pointer_down
-    @property
-    def on_pointer_down(self) -> OptionalEventCallable["MapPointerEvent"]:
-        return self.__on_pointer_down.handler
-
-    @on_pointer_down.setter
-    def on_pointer_down(self, handler: OptionalEventCallable["MapPointerEvent"]):
-        self.__on_pointer_down.handler = handler
-        self._set_attr("onPointerDown", True if handler is not None else None)
-
-    # on_pointer_cancel
-    @property
-    def on_pointer_cancel(self) -> OptionalEventCallable["MapPointerEvent"]:
-        return self.__on_pointer_cancel.handler
-
-    @on_pointer_cancel.setter
-    def on_pointer_cancel(self, handler: OptionalEventCallable["MapPointerEvent"]):
-        self.__on_pointer_cancel.handler = handler
-        self._set_attr("onPointerCancel", True if handler is not None else None)
-
-    # on_pointer_up
-    @property
-    def on_pointer_up(self) -> OptionalEventCallable["MapPointerEvent"]:
-        return self.__on_pointer_up.handler
-
-    @on_pointer_up.setter
-    def on_pointer_up(self, handler: OptionalEventCallable["MapPointerEvent"]):
-        self.__on_pointer_up.handler = handler
-        self._set_attr("onPointerUp", True if handler is not None else None)
-
-
-class MapEventSource(Enum):
-    MAP_CONTROLLER = "mapController"
-    TAP = "tap"
-    SECONDARY_TAP = "secondaryTap"
-    LONG_PRESS = "longPress"
-    DOUBLE_TAP = "doubleTap"
-    DOUBLE_TAP_HOLD = "doubleTapHold"
-    DRAG_START = "dragStart"
-    ON_DRAG = "onDrag"
-    DRAG_END = "dragEnd"
-    MULTI_FINGER_GESTURE_START = "multiFingerGestureStart"
-    ON_MULTI_FINGER = "onMultiFinger"
-    MULTI_FINGER_GESTURE_END = "multiFingerEnd"
-    FLING_ANIMATION_CONTROLLER = "flingAnimationController"
-    DOUBLE_TAP_ZOOM_ANIMATION_CONTROLLER = "doubleTapZoomAnimationController"
-    INTERACTIVE_FLAGS_CHANGED = "interactiveFlagsChanged"
-    FIT_CAMERA = "fitCamera"
-    CUSTOM = "custom"
-    SCROLL_WHEEL = "scrollWheel"
-    NON_ROTATED_SIZE_CHANGE = "nonRotatedSizeChange"
-    CURSOR_KEYBOARD_ROTATION = "cursorKeyboardRotation"
-
-
-class MapTapEvent(ControlEvent):
-    def __init__(self, e: ControlEvent) -> None:
-        super().__init__(e.target, e.name, e.data, e.control, e.page)
-        d = json.loads(e.data)
-        self.local_x: Optional[float] = d.get("lx")
-        self.local_y: Optional[float] = d.get("ly")
-        self.global_x: float = d.get("gx")
-        self.global_y: float = d.get("gy")
-        self.coordinates: MapLatitudeLongitude = MapLatitudeLongitude(
-            d.get("lat"), d.get("long")
-        )
-
-
-class MapHoverEvent(ControlEvent):
-    def __init__(self, e: ControlEvent) -> None:
-        super().__init__(e.target, e.name, e.data, e.control, e.page)
-        d = json.loads(e.data)
-        self.local_x: Optional[float] = d.get("lx")
-        self.local_y: Optional[float] = d.get("ly")
-        self.global_x: float = d.get("gx")
-        self.global_y: float = d.get("gy")
-        self.device_type: MapPointerDeviceType = MapPointerDeviceType(d.get("kind"))
-        self.coordinates: MapLatitudeLongitude = MapLatitudeLongitude(
-            d.get("lat"), d.get("long")
-        )
-
-
-class MapPositionChangeEvent(ControlEvent):
-    def __init__(self, e: ControlEvent) -> None:
-        super().__init__(e.target, e.name, e.data, e.control, e.page)
-        d = json.loads(e.data)
-        self.min_zoom: Optional[float] = d.get("min_zoom")
-        self.max_zoom: Optional[float] = d.get("max_zoom")
-        self.rotation: float = d.get("rot")
-        self.coordinates: MapLatitudeLongitude = MapLatitudeLongitude(
-            d.get("lat"), d.get("long")
-        )
-
-
-class MapPointerEvent(ControlEvent):
-    def __init__(self, e: ControlEvent) -> None:
-        super().__init__(e.target, e.name, e.data, e.control, e.page)
-        d = json.loads(e.data)
-        self.device_type: MapPointerDeviceType = MapPointerDeviceType(d.get("kind"))
-        self.global_y: float = d.get("gy")
-        self.global_x: float = d.get("gx")
-        self.coordinates: MapLatitudeLongitude = MapLatitudeLongitude(
-            d.get("lat"), d.get("long")
-        )
-
-
-class MapEvent(ControlEvent):
-    def __init__(self, e: ControlEvent) -> None:
-        super().__init__(e.target, e.name, e.data, e.control, e.page)
-        d = json.loads(e.data)
-        self.source: MapEventSource = MapEventSource(d.get("src"))
-        self.center: MapLatitudeLongitude = MapLatitudeLongitude(
-            d.get("c_lat"), d.get("c_long")
+    def center_on(
+        self,
+        point: Optional[MapLatitudeLongitude],
+        zoom: Optional[ft.Number],
+        animation_curve: Optional[ft.AnimationCurve] = None,
+        animation_duration: Optional[ft.DurationValue] = None,
+        cancel_ongoing_animations: bool = False,
+    ) -> None:
+        """
+        Centers the map on the given point.
+
+        Args:
+            point: The point on which to center the map.
+            zoom: The zoom level to be applied.
+            animation_curve: The curve of the animation. If None (the default), `Map.animation_curve` will be used.
+            animation_duration: The duration of the animation. If None (the default), `Map.animation_duration` will be used.
+            cancel_ongoing_animations: Whether to cancel/stop all ongoing map-animations before starting this new one.
+        """
+        asyncio.create_task(
+            self.center_on_async(
+                point,
+                zoom,
+                animation_curve,
+                animation_duration,
+                cancel_ongoing_animations,
+            )
         )
-        self.zoom: float = d.get("zoom")
-        self.min_zoom: float = d.get("min_zoom")
-        self.max_zoom: float = d.get("max_zoom")
-        self.rotation: float = d.get("rot")