Cleanup and refactoring

Minor bug fixes
Improved documentation

Author: JaffaKetchup

example/lib/pages/home.dart

@@ -38,7 +38,7 @@ class _HomePageState extends State<HomePage> {
               initialZoom: 5,
             ),
             children: [
-              RasterTileLayer.simple(
+              const RasterTileLayer.simple(
                 urlTemplate: 'https://tile.openstreetmap.org/{z}/{x}/{y}.png',
                 uaIdentifier: 'dev.fleaflet.flutter_map.demo',
               ),

lib/flutter_map.dart

@@ -29,15 +29,7 @@ export 'package:flutter_map/src/layer/attribution_layer/rich/widget.dart';
 export 'package:flutter_map/src/layer/attribution_layer/simple.dart';
 export 'package:flutter_map/src/layer/circle_layer/circle_layer.dart';
 export 'package:flutter_map/src/layer/marker_layer/marker_layer.dart';
-export 'package:flutter_map/src/layer/modern_tile_layer/source_generators/source_generator.dart';
-export 'package:flutter_map/src/layer/modern_tile_layer/source_generators/wms.dart';
-export 'package:flutter_map/src/layer/modern_tile_layer/source_generators/xyz.dart';
-export 'package:flutter_map/src/layer/modern_tile_layer/tile_layers/raster/tile_layer.dart';
-export 'package:flutter_map/src/layer/modern_tile_layer/tile_loader/bytes_fetchers/network/caching/built_in/built_in_caching_provider.dart';
-export 'package:flutter_map/src/layer/modern_tile_layer/tile_loader/bytes_fetchers/network/caching/caching_provider.dart';
-export 'package:flutter_map/src/layer/modern_tile_layer/tile_loader/bytes_fetchers/network/caching/disabled/disabled_caching_provider.dart';
-export 'package:flutter_map/src/layer/modern_tile_layer/tile_loader/bytes_fetchers/network/caching/tile_metadata.dart';
-export 'package:flutter_map/src/layer/modern_tile_layer/tile_loader/bytes_fetchers/network/caching/tile_read_failure_exception.dart';
+export 'package:flutter_map/src/layer/modern_tile_layer/modern_tile_layer.dart';
 export 'package:flutter_map/src/layer/overlay_image_layer/overlay_image_layer.dart';
 export 'package:flutter_map/src/layer/polygon_layer/label/deprecated_placements.dart';
 export 'package:flutter_map/src/layer/polygon_layer/label/placement_calculators/placement_calculator.dart';

lib/src/layer/modern_tile_layer/README.md

@@ -22,7 +22,7 @@ It does this by:
 
 * using a canvas implementation for the default raster tile layer
 
-Significant uestions remaining:
+Significant questions remaining:
 
 * Is the default tile loader setup (with two stages) too much frameworking/overly-complicated?
 * Simulating retina mode affects all parts of the system - but only (conceptually/for reasoning) applies to raster tiles (although technically it's no different to a top layer option). How should this be represented?

lib/src/layer/modern_tile_layer/base_tile_data.dart

@@ -57,7 +57,6 @@ class WrapperTileData<D extends Object?> implements BaseTileData {
   Future<D> get triggerPrune => _loadedTracker.future;
 
   /// Whether [data] represents the loaded data
-  @override
   bool get isLoaded => _loadedTracker.isCompleted;
 
   @internal

lib/src/layer/modern_tile_layer/base_tile_layer.dart

@@ -1,12 +1,9 @@
 import 'dart:async';
-import 'dart:collection';
 
 import 'package:flutter/widgets.dart';
 import 'package:flutter_map/flutter_map.dart';
-import 'package:flutter_map/src/layer/modern_tile_layer/base_tile_data.dart';
-import 'package:flutter_map/src/layer/modern_tile_layer/options.dart';
-import 'package:flutter_map/src/layer/modern_tile_layer/tile_loader/tile_loader.dart';
 import 'package:latlong2/latlong.dart';
+import 'package:logger/logger.dart';
 import 'package:meta/meta.dart';
 
 /// A map layer formed from adjacent square tiles loaded individually on demand
@@ -24,7 +21,6 @@ class BaseTileLayer<D extends BaseTileData> extends StatefulWidget {
   final Widget Function(
     BuildContext context,
     Object layerKey,
-    TileLayerOptions options,
     Map<({TileCoordinates coordinates, Object layerKey}), D> visibleTiles,
   ) renderer;
 
@@ -52,6 +48,8 @@ class _BaseTileLayerState<D extends BaseTileData>
     if (oldWidget.options != widget.options ||
         oldWidget.tileLoader != widget.tileLoader ||
         oldWidget.renderer != widget.renderer) {
+      // TODO: Remove
+      Logger(printer: SimplePrinter()).d('Generating new `layerKey`');
       layerKey = UniqueKey();
     }
   }
@@ -102,8 +100,7 @@ class _BaseTileLayerState<D extends BaseTileData>
     return widget.renderer(
       context,
       layerKey,
-      widget.options,
-      Map.unmodifiable(tiles.map((k, v) => MapEntry(k, v._data))),
+      Map.unmodifiable(tiles.map((k, v) => MapEntry(k, v.data))),
     );
   }
 
@@ -239,28 +236,39 @@ typedef _TileKey = ({TileCoordinates coordinates, Object layerKey});
 extension type _TilesTracker<D extends BaseTileData>._(
         Map<_TileKey, _TileDataWithPrunableIndicator<D>> _map)
     implements Map<_TileKey, _TileDataWithPrunableIndicator<D>> {
-  _TilesTracker()
-      : this._(
-          Map<_TileKey, _TileDataWithPrunableIndicator<D>>(
-              /*(a, b) =>
-                a.coordinates.z.compareTo(b.coordinates.z) |
-                a.coordinates.x.compareTo(b.coordinates.x) |
-                a.coordinates.y.compareTo(b.coordinates.y),*/
-              ),
-        );
+  _TilesTracker() : this._(<_TileKey, _TileDataWithPrunableIndicator<D>>{});
 
+  // ignore: experimental_member_use
   @redeclare
-  D? remove(Object? key) => (_map.remove(key)?..dispose())?._data;
+  void removeWhere(
+    bool Function(_TileKey key, _TileDataWithPrunableIndicator<D> value) test,
+  ) {
+    final keysToRemove = <_TileKey>[];
+    for (final MapEntry(:key, :value) in _map.entries) {
+      if (test(key, value)) keysToRemove.add(key);
+    }
+    for (final key in keysToRemove) {
+      remove(key);
+    }
+  }
+
+  // ignore: experimental_member_use
+  @redeclare
+  D? remove(Object? key) {
+    //print(StackTrace.current);
+    return (_map.remove(key)?..dispose())?.data;
+  }
 }
 
 class _TileDataWithPrunableIndicator<D extends BaseTileData> {
-  _TileDataWithPrunableIndicator(D data) : _data = data {
-    _data.triggerPrune.then((_) => isPrunable = true);
+  _TileDataWithPrunableIndicator(this.data) {
+    data.triggerPrune.then((_) => isPrunable = true);
   }
 
-  final D _data;
-  Future<void> get triggerPrune => _data.triggerPrune;
-  void dispose() => _data.dispose();
+  final D data;
+
+  Future<void> get triggerPrune => data.triggerPrune;
+  void dispose() => data.dispose();
 
   /// `true` when [BaseTileData.triggerPrune] has completed.
   ///

lib/src/layer/modern_tile_layer/modern_tile_layer.dart

@@ -0,0 +1,5 @@
+export 'base_tile_data.dart';
+export 'base_tile_layer.dart';
+export 'options.dart';
+export 'tile_layers/raster/raster.dart';
+export 'tile_loader/tile_loader.dart';

lib/src/layer/modern_tile_layer/tile_layers/raster/options.dart

@@ -0,0 +1,17 @@
+import 'package:flutter/widgets.dart';
+import 'package:flutter_map/flutter_map.dart';
+
+@immutable
+class RasterTileLayerOptions {
+  const RasterTileLayerOptions({this.crs});
+
+  final Crs? crs;
+
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      (other is RasterTileLayerOptions && crs == other.crs);
+
+  @override
+  int get hashCode => Object.hash(crs, null);
+}

lib/src/layer/modern_tile_layer/tile_layers/raster/raster.dart

@@ -0,0 +1,2 @@
+export 'options.dart';
+export 'tile_layer.dart';

lib/src/layer/modern_tile_layer/tile_layers/raster/renderer.dart

@@ -0,0 +1,119 @@
+part of 'tile_layer.dart';
+
+class _RasterRenderer extends StatefulWidget {
+  _RasterRenderer({
+    required Object layerKey,
+    required this.visibleTiles,
+    required this.options,
+    required this.rasterOptions,
+  }) : super(key: ValueKey(layerKey));
+
+  final Map<({TileCoordinates coordinates, Object layerKey}), RasterTileData>
+      visibleTiles;
+  final TileLayerOptions options;
+  final RasterTileLayerOptions rasterOptions;
+
+  @override
+  State<_RasterRenderer> createState() => __RasterRendererState();
+}
+
+class __RasterRendererState extends State<_RasterRenderer> {
+  late var _tileScaleCalculator = _generateTileScaleCalculator();
+  TileScaleCalculator _generateTileScaleCalculator() => TileScaleCalculator(
+        crs: widget.rasterOptions.crs ?? const Epsg3857(),
+        tileDimension: widget.options.tileDimension,
+      );
+
+  @override
+  void didUpdateWidget(covariant _RasterRenderer oldWidget) {
+    super.didUpdateWidget(oldWidget);
+
+    if (widget.rasterOptions.crs != oldWidget.rasterOptions.crs ||
+        widget.options.tileDimension != oldWidget.options.tileDimension) {
+      _tileScaleCalculator = _generateTileScaleCalculator();
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final map = MapCamera.of(context);
+
+    _tileScaleCalculator.clearCacheUnlessZoomMatches(map.zoom);
+
+    return MobileLayerTransformer(
+      child: CustomPaint(
+        size: Size.infinite,
+        willChange: true,
+        painter: _RasterPainter(
+          options: widget.options,
+          visibleTiles: widget.visibleTiles.entries.map(
+            (tile) => (
+              coordinates: tile.key.coordinates,
+              scaledTileDimension: _tileScaleCalculator.scaledTileDimension(
+                map.zoom,
+                tile.key.coordinates.z,
+              ),
+              currentPixelOrigin: map.pixelOrigin,
+              data: tile.value,
+            ),
+          ),
+          //tiles: tiles..sort(renderOrder),
+          //tilePaint: widget.tilePaint,
+          //tileOverlayPainter: widget.tileOverlayPainter,
+        ),
+      ),
+    );
+  }
+}
+
+class _RasterPainter extends CustomPainter {
+  final TileLayerOptions options;
+  final Iterable<
+      ({
+        TileCoordinates coordinates,
+        double scaledTileDimension,
+        Offset currentPixelOrigin,
+        RasterTileData data
+      })> visibleTiles;
+
+  _RasterPainter({
+    super.repaint,
+    required this.options,
+    required this.visibleTiles,
+  });
+
+  final Paint _basePaint = (null ?? Paint())
+    ..filterQuality = FilterQuality.high
+    ..isAntiAlias = true;
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    for (final tile in visibleTiles) {
+      if (tile.data.loaded?.successfulImageInfo?.image case final image?) {
+        final origin = Offset(
+          tile.coordinates.x * tile.scaledTileDimension -
+              tile.currentPixelOrigin.dx,
+          tile.coordinates.y * tile.scaledTileDimension -
+              tile.currentPixelOrigin.dy,
+        );
+
+        //final paint = _basePaint
+        //  ..color = (null?.color.withOpacity(tile.tileImage.opacity) ??
+        //      Color.fromRGBO(0, 0, 0, tile.tileImage.opacity));
+
+        canvas.drawImageRect(
+          image,
+          Offset.zero &
+              Size(image.width.toDouble(), image.height.toDouble()), // src
+          origin & Size.square(tile.scaledTileDimension), // dest
+          _basePaint,
+        );
+      }
+    }
+  }
+
+  @override
+  bool shouldRepaint(covariant CustomPainter oldDelegate) {
+    return true;
+  }
+}