Add MapEventNonRotatedSizeChange

This new event is triggered when the map's non-rotated size is changed,
it is not called when the map is initialized. This will fix TileLayer
not loading new tiles when the map size changes.

In passing I made some other improvements:

 - Expose nonRotatedSize’s full type (CustomPoint<double>? instead of
   CustomPoint?) to avoid unnecessary type casts.
 - Improve the check for the constraints being ready before setting initial
   zoom/center based on MapOptions bounds.
 - Remove unnecessary setState in FlutterMapState’s emitMapEvent. The
   event emitting does not change the map's state and was causing double
   calls to setState in some code paths.
 - FlutterMapState tidy ups.
 - Removed the workaround for the initial map size being zero in TileLayer
   which caused tiles to not be loaded. The new MapEventNonRotatedSizeChange
   event removes the need for this workaround as during startup either:
     - The platform has already set flutter's resolution and thus all
       tiles are successfully loaded.
     - The platform has not set flutter's resolution but when it does it
       will cause LayoutBuilder to rebuild with the new size which will
       trigger a MapEventNonRotatedSizeChange event. This event will in
       turn trigger a tile load in TileLayer.

lib/src/gestures/gestures.dart

@@ -555,8 +555,7 @@ abstract class MapGestureMixin extends State<FlutterMap>
 
     final direction = details.velocity.pixelsPerSecond / magnitude;
     final distance = (Offset.zero &
-            Size(mapState.nonrotatedSize!.x as double,
-                mapState.nonrotatedSize!.y as double))
+            Size(mapState.nonrotatedSize!.x, mapState.nonrotatedSize!.y))
         .shortestSide;
 
     final flingOffset = _focalStartLocal - _lastFocalLocal;

lib/src/gestures/map_events.dart

@@ -1,3 +1,4 @@
+import 'package:flutter_map/src/core/point.dart';
 import 'package:latlong2/latlong.dart';
 
 /// Event sources which are used to identify different types of
@@ -21,6 +22,7 @@ enum MapEventSource {
   fitBounds,
   custom,
   scrollWheel,
+  nonRotatedSizeChange,
 }
 
 /// Base event class which is emitted by MapController instance, the event
@@ -59,6 +61,59 @@ abstract class MapEventWithMove extends MapEvent {
     required super.center,
     required super.zoom,
   });
+
+  /// Returns a subclass of [MapEventWithMove] if the [source] belongs to a
+  /// movement event, otherwise returns null.
+  static MapEventWithMove? fromSource({
+    required LatLng targetCenter,
+    required double targetZoom,
+    required LatLng oldCenter,
+    required double oldZoom,
+    required bool hasGesture,
+    required MapEventSource source,
+    String? id,
+  }) {
+    switch (source) {
+      case MapEventSource.flingAnimationController:
+        return MapEventFlingAnimation(
+          center: oldCenter,
+          zoom: oldZoom,
+          targetCenter: targetCenter,
+          targetZoom: targetZoom,
+          source: source,
+        );
+      case MapEventSource.doubleTapZoomAnimationController:
+        return MapEventDoubleTapZoom(
+          center: oldCenter,
+          zoom: oldZoom,
+          targetCenter: targetCenter,
+          targetZoom: targetZoom,
+          source: source,
+        );
+      case MapEventSource.scrollWheel:
+        return MapEventScrollWheelZoom(
+          center: oldCenter,
+          zoom: oldZoom,
+          targetCenter: targetCenter,
+          targetZoom: targetZoom,
+          source: source,
+        );
+      case MapEventSource.onDrag:
+      case MapEventSource.onMultiFinger:
+      case MapEventSource.mapController:
+      case MapEventSource.custom:
+        return MapEventMove(
+          id: id,
+          center: oldCenter,
+          zoom: oldZoom,
+          targetCenter: targetCenter,
+          targetZoom: targetZoom,
+          source: source,
+        );
+      default:
+        return null;
+    }
+  }
 }
 
 /// Event which is fired when map is tapped
@@ -260,3 +315,13 @@ class MapEventRotateEnd extends MapEvent {
     required super.zoom,
   });
 }
+
+class MapEventNonRotatedSizeChange extends MapEvent {
+  const MapEventNonRotatedSizeChange({
+    required super.source,
+    required CustomPoint<double> previousNonRotatedSize,
+    required CustomPoint<double> nonRotatedSize,
+    required super.center,
+    required super.zoom,
+  });
+}

lib/src/layer/tile_layer/tile_layer.dart

@@ -375,12 +375,7 @@ class _TileLayerState extends State<TileLayer> with TickerProviderStateMixin {
       );
     }
 
-    if (reloadTiles) {
-      _tryWaitForSizeToBeInitialized(
-        mapState,
-        () => _loadAndPruneInVisibleBounds(mapState),
-      );
-    }
+    if (reloadTiles) _loadAndPruneInVisibleBounds(mapState);
 
     _initializedFromMapState = true;
   }
@@ -658,27 +653,4 @@ class _TileLayerState extends State<TileLayer> with TickerProviderStateMixin {
 
   bool _outsideZoomLimits(num zoom) =>
       zoom < widget.minZoom || zoom > widget.maxZoom;
-
-  // A workaround for the fact that FlutterMapState size initialization has a
-  // race condition where sometimes the size is set to CustomPoint(0,0) before
-  // it is set to the correct value. When this occurs, code that relies on the
-  // visible bounds will not work correctly. Sometimes it requires more than
-  // one postFrameCallback to get a non zero size.
-  void _tryWaitForSizeToBeInitialized(
-    FlutterMapState mapState,
-    VoidCallback callback, {
-    int retries = 3,
-  }) {
-    if (retries >= 0 && mapState.size == const CustomPoint(0, 0)) {
-      WidgetsBinding.instance.addPostFrameCallback((_) {
-        _tryWaitForSizeToBeInitialized(
-          mapState,
-          callback,
-          retries: retries - 1,
-        );
-      });
-    } else {
-      callback();
-    }
-  }
 }