child: FlutterMap(
              options: MapOptions(
                initialCenter: const LatLng(56.704173, 11.543808),
               // **Remove min zoom to be able to display zoom level 0** 
               //**minZoom: 12,
                maxZoom: 14,
                initialZoom: 13,
                // **Remove camera constraints to explore the whole world**
                //cameraConstraint: CameraConstraint.containCenter(
                //  bounds: LatLngBounds(northEast, southWest),
                //),
              ),

import 'dart:io';
import 'dart:math' as math;

import 'package:flutter/material.dart';
import 'package:flutter_map/flutter_map.dart';


class FileZoomingTileProvider extends TileProvider {
  FileZoomingTileProvider();

  @override
  ImageProvider getImage(TileCoordinates coordinates, TileLayer options) {
    bool checkTileExists = false;
    int increment = 0;
    File tileFile = File(getTileUrl(coordinates, options));

    // Si la tuile n'existe pas, on va chercher la tuile de niveau supérieure qui est dispo
    while ((!checkTileExists) && (coordinates.z > increment - 1)) {
      final TileCoordinates currentTile = TileCoordinates(
          (coordinates.x / math.pow(2, increment)).floor(),
          (coordinates.y / math.pow(2, increment)).floor(),
          coordinates.z - increment);
      tileFile = File(getTileUrl(currentTile, options));

      checkTileExists = tileFile.existsSync();
      increment++;
    }

    if (checkTileExists && (increment == 1)) {
      // La tuile a été trouvé à la première itération
      return FileImage(tileFile);
    } else if (checkTileExists) {
      // Il a fallu aller chercher une tuile de niveau supérieur => on la rescale
      return FileImage(tileFile, scale: increment.toDouble());
    } else {
      // La tuile n'a été trouvé -> on passe par le fallback
      final fallbackUrl = getTileFallbackUrl(coordinates, options);
      if (fallbackUrl == null) return FileImage(tileFile);
      return FileImage(File(fallbackUrl));
    }
  }
}


class RectCustomClipper extends CustomClipper<Rect> {
  final double top;
  final double left;
  final Size size;

  RectCustomClipper(this.top, this.left, this.size);
  @override
  Rect getClip(Size size) => Rect.fromLTWH(left, top, size.width, size.height);

  @override
  bool shouldReclip(covariant CustomClipper<Rect> oldClipper) => oldClipper != this;
}

class TileTransformer {
  Widget widget;

  TileTransformer(this.widget);

  void scaleClipOffsetTile(TileCoordinates coordinates, int scale) {
    _offsetTile(scale, coordinates);
    _scaleTile(scale, coordinates);
    _clipTile();
  }

  void _offsetTile(int scale, TileCoordinates coordinates) {
    final int scaleFactor = math.pow(2, scale - 1).toInt();

    final Offset offset = Offset(
      256 * (coordinates.x % scaleFactor) / scaleFactor,
      256 * (coordinates.y % scaleFactor) / scaleFactor,
    );

    widget = Transform.translate(
      offset: -offset,
      child: widget,
    );
  }

  void _clipTile() {
    widget = ClipRect(
      clipper: RectCustomClipper(0, 0, const Size(256, 256)),
      child: widget,
    );
  }

  void _scaleTile(int scale, TileCoordinates coordinates) {
    final double scaleFactor = math.pow(2, scale - 1).toDouble();

    widget = Transform.scale(
      scale: scaleFactor,
      alignment: Alignment.topLeft,
      child: widget,
    );
  }
}

Widget FileZoomingTileBuilder(BuildContext context, Widget tileWidget, TileImage tile) {
  final double scale = (tile.imageProvider as FileImage).scale;
  Widget widget;


  if (scale < 2) {
    widget = tileWidget;
  }
  else {
    // On récupère une partie de la tuile qu'on va zoomer en fonction de l'échelle
    final TileTransformer tileTransformer = TileTransformer(tileWidget);
    tileTransformer.scaleClipOffsetTile(
      tile.coordinates,
      scale.floor(),
    );
    widget = tileTransformer.widget;
  }

  final readableKey = '${tile.coordinates.x} : ${tile.coordinates.y} : ${tile.coordinates.z}';
  return Stack(
      fit: StackFit.passthrough,
      children: [
        widget,
        DecoratedBox(
          decoration: BoxDecoration(
            border: Border.all(
              color: Colors.red,
            ),
          ),
          child: const SizedBox(width: 256, height: 256),
        ),
        Center(
          child: Text(
            readableKey,
            style: Theme.of(context).textTheme.headlineSmall,
          ),
        ),
      ]
  );
}

    _map_flat = TileLayer(
      urlTemplate: "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
      userAgentPackageName: 'com.xyz.abc',
      tileProvider: provider,
      subdomains: ['a', 'b', 'c'],
      maxNativeZoom: 30,
    );