fleaflet/flutter_map

This system is a Flutter mapping library that provides a comprehensive framework for rendering interactive 2D maps across mobile, desktop, and web platforms. It supports multiple coordinate reference systems and layer types, including tiles, markers, polygons, polylines, and circles, with granular control over gestures, camera constraints, and rendering performance. The library includes built-in utilities for tile caching, request cancellation, and geometric calculations, alongside a structured example application that demonstrates these capabilities.

16 changes.

The project underwent a comprehensive modernization, migrating the example app to Flutter V2 embedding, Kotlin DSL, and Material 3 while raising platform minimums. Internally, the library consolidated its public API into a single entry point and refactored core geometry and gesture systems to support granular interaction flags and improved performance.

32 changes.

This period focused on a major architectural overhaul of the TileLayer, introducing a new provider interface, refined bounds calculation, and improved rendering lifecycle. Concurrently, the project expanded its example application to support web, macOS, and Windows platforms while significantly increasing test coverage and adding granular camera and interaction controls.

15 changes.

This period focused on refactoring the map layer system to introduce standardized interactivity, projection caching, and shared simplification infrastructure. New layer types such as CircleLayer, OverlayImageLayer, and Scalebar were added, alongside significant performance optimizations for polylines, markers, and network tile loading.

Introduces a new \Scalebar\ widget that can be added to the \FlutterMap.children\ list to display a distance scale on the map. The widget supports configuration for alignment, text styling, line color, stroke width, and padding, and automatically calculates the appropriate metric label (meters or kilometers) based on the current zoom level and map center.

lib/src/layer/scalebar · high confidence

A new SimpleAttributionWidget is introduced to provide a classic, minimal attribution overlay for maps. It displays a padded, translucent box containing the text 'flutter\_map \| © \[source\]', where the source text is tappable via an optional callback. The widget allows customization of the background color, anchor alignment (defaulting to bottom-right), and integrates with the app theme for surface colors, offering a lightweight alternative to the more complex RichAttributionWidget.

_lib/src/layer/attribution\layer · high confidence

The example application now includes a new \PrimaryTileLayer\ widget in \example/lib/misc/tile\_providers.dart\ that demonstrates loading OpenStreetMap tiles. This implementation uses a retry-capable HTTP client for network requests and displays a rich attribution widget that links to the OpenStreetMap copyright page.

example/lib/misc · high confidence

The example application now includes the necessary files to build and distribute a native Windows desktop version. This adds a CMakeLists.txt to configure the build process, a .gitignore to exclude Visual Studio and build artifacts, and an Inno Setup script (installer-config.iss) to package the application for installation. Users can now build the example as a standalone Windows executable and create an installer package.

example/windows · high confidence

The example application now includes a complete macOS target, enabling users to build and run the app on macOS. This addition introduces the native Xcode project structure, including the \Runner\ target with \AppDelegate.swift\ and \MainFlutterWindow.swift\, and configures CocoaPods integration via \Pods\_Runner.framework\. It also registers specific Flutter plugins—\path\_provider\_foundation\, \shared\_preferences\_foundation\, and \url\_launcher\_macos\—and applies macOS-specific settings such as app sandboxing entitlements and standard macOS menu interfaces.

example/macos · high confidence

The example application now supports running on the web platform. This change introduces the necessary \index.html\ entry point and \manifest.json\ configuration, enabling users to launch and interact with the map demo directly in a browser.

example/web · high confidence

The example application now includes a new \FlutterMapZoomButtons\ widget in the plugins directory. This component provides customizable zoom-in and zoom-out floating action buttons that allow users to adjust the map view by exactly one zoom level at a time, respecting configured minimum and maximum zoom limits.

example/lib/plugins · high confidence

Network tile loading now includes built-in support for caching tiles to the local filesystem on native platforms and cancelling in-flight HTTP requests for obsolete tiles. The \NetworkTileProvider\ automatically uses a \BuiltInMapCachingProvider\ (enabled by default) to store tiles based on HTTP headers, with a configurable maximum cache size (defaulting to 1 GB) and background size reduction. Users can disable caching by passing \DisabledMapCachingProvider\ or configure the cache directory and limits. Additionally, the \abortObsoleteRequests\ option (defaulting to \true\) allows the provider to abort HTTP requests for tiles that are no longer needed, improving performance and reducing network usage, particularly on web platforms.

_lib/src/layer/tile\_layer/tile\provider/network · high confidence

The example application's page structure has been significantly reorganized and expanded to showcase new library capabilities. New demo pages include \AbortObsoleteRequestsPage\ to demonstrate the v8.2.0 feature that aborts in-flight HTTP requests for tiles no longer displayed, and \DebouncingTileUpdateTransformerPage\ to illustrate the \TileUpdateTransformers.debounce\ mechanism for reducing tile requests. Interactive behavior is highlighted in \InteractiveFlagsPage\, which allows toggling various gesture flags (drag, pinch, keyboard controls, smooth scroll zooming), and \FlingAnimationDampingPage\, which lets users customize the \flingAnimationDampingRatio\. Performance and rendering features are demonstrated in \ManyCirclesPage\ (testing up to 30,000 circles with \optimizeRadiusInMeters\), \ManyMarkersPage\ (stress testing 20,000 markers), and \CirclePage\ (showcasing hit detection and hover effects on \CircleLayer\). Additional demos cover \AnimatedMapControllerPage\ for smooth camera transitions, \BundledOfflineMapPage\ for offline asset tiles, \LatLngToScreenPointPage\ for coordinate conversion, and custom CRS examples (\EPSG3996Page\, \EPSG4326Page\). The \HomePage\ now uses a \FloatingMenuButton\ for navigation.

example/lib/pages · high confidence

The example application now includes essential configuration and metadata files to support development and publishing workflows. A \.gitignore\ file is added to exclude build artifacts and IDE-specific files, while a \.pubignore\ file ensures only necessary assets are included in the published package. A \.metadata\ file tracks the Flutter SDK revision and migration state for the project's platforms. Additionally, an \analysis\_options.yaml\ file is introduced to apply linting rules inherited from the main library, and a \README.md\ provides instructions on how to run the demo app and an overview of its structure.

example · high confidence

A new \RichAttributionWidget\ is added to the attribution layer, allowing users to display both text and logo attributions with a popup box that can be toggled via an open/close button. The widget supports configurable animations (fade or scale) for the popup and button states, and allows customization of alignment, colors, and border radius. It includes prebuilt animation classes \FadeRAWA\ and \ScaleRAWA\, and attribution source classes \TextSourceAttribution\ and \LogoSourceAttribution\ for flexible content display.

_lib/src/layer/attribution\layer/rich · high confidence

A new AssetTileProvider class has been added to allow map tiles to be loaded directly from the application's bundled assets. This provider uses Flutter's AssetImage internally and supports a fallback URL mechanism via a custom CachingAssetBundle, though users are advised to avoid specifying fallback URLs as this custom bundle is approximately 23% slower than the default. All tile assets must be listed in the pubspec.yaml file as usual.

_lib/src/layer/tile\_layer/tile\provider/asset · high confidence

A new CircleLayer has been introduced to display a list of CircleMarkers on the map. This layer supports hit detection via a hitNotifier, allowing users to interact with individual circles. It also includes an optimizeRadiusInMeters option that improves performance by reusing the meters-to-pixels conversion ratio across all circles in the layer, though this may reduce accuracy if circles are geographically spread out.

_lib/src/layer/circle\layer · high confidence

The example app now includes a complete Windows runner in the \example/windows/runner\ directory, providing the native C++ entry point and build configuration required to run the Flutter application on Windows. This addition introduces a new \CMakeLists.txt\ build script, a \Win32Window\ class for high-DPI and theme-aware window management, and a \FlutterWindow\ class that hosts the Flutter engine. Users can now build and run the demo on Windows, with the runner handling console attachment, command-line argument conversion, and proper window lifecycle management.

example/windows/runner · high confidence

The map library introduces a new system for managing camera boundaries and positioning. Users can now enforce movement limits using \CameraConstraint\, which includes options to keep the camera center within specific bounds (\ContainCameraCenter\), keep the entire viewport within bounds (\ContainCamera\), or restrict latitude ranges to prevent showing empty space at the poles (\ContainCameraLatitude\). Additionally, \CameraFit\ provides new methods to automatically adjust the map view, such as fitting the camera inside specific bounds (\FitInsideBounds\) or fitting to a list of coordinates with support for rotated maps. These changes allow for more robust and predictable map interactions, ensuring the view stays within desired geographic or logical boundaries.

lib/src/map/camera · high confidence

The map now exposes detailed configuration for user interactions via new \InteractionOptions\, \CursorKeyboardRotationOptions\, \KeyboardOptions\, and \ScrollZoomOptions\ classes. Users can now customize double-tap drag zoom behavior, enable smooth animated scroll zooming (default) or snap zooming, and adjust fling animation damping. Desktop-specific controls are enhanced with configurable cursor/keyboard rotation (including North-setting on click and trigger keys) and comprehensive keyboard support for panning (arrow keys, WASD), rotating (Q/E), and zooming (R/F), including customizable animation curves and 'leap' mechanics. The legacy \scrollWheelVelocity\ property is deprecated in favor of the new \ScrollZoomOptions\ structure.

lib/src/map/options · high confidence

A new \OverlayImageLayer\ has been introduced to display images on the map, supporting both standard bounding-box placement (\OverlayImage\) and rotated/skewed placement (\RotatedOverlayImage\). Users can now control the rendering quality of these images via a \filterQuality\ parameter (defaulting to medium) on the base class, and additionally configure \transformFilterQuality\ specifically for rotated images to manage raster cache behavior during transformations.

_lib/src/layer/overlay\_image\layer · high confidence

Added support for precise dashed and dotted stroke patterns on polylines and polygon borders. The new \StrokePattern\ class allows users to define dotted lines with a configurable spacing factor or dashed lines with custom segment and gap lengths. A \PatternFit\ enum controls how patterns are rendered when line lengths do not align perfectly with the pattern cycle, offering options to scale the pattern, append a final dot, or extend the final dash to the endpoint. This implementation uses a pixel-hiker algorithm to calculate visible segments, ensuring patterns remain consistent and accurate during map zooming and panning.

_lib/src/layer/shared/line\patterns · high confidence

The \lib/src/map/controller\ area now introduces a new \MapController\ abstract class and its \MapControllerImpl\ to allow programmatic interaction with the map. Users can now move, zoom, and rotate the map via methods like \move\, \rotate\, \rotateAroundPoint\, and \fitCamera\, as well as perform combined operations with \moveAndRotate\. The controller exposes a \mapEventStream\ for listening to map events and provides access to the current \MapCamera\. It also supports animations for smooth transitions and allows reassignment to the \FlutterMap\ widget multiple times.

lib/src/map/controller · high confidence

This change introduces three new files in the shared layer module to support map layer functionality. \feature\_layer\_utils.dart\ adds a mixin for feature layers that provides viewport rectangle tracking, offset visibility checks, and a \workAcrossWorlds\ method with infinite-loop protection for multi-world rendering. \mobile\_layer\_transformer.dart\ adds a widget that applies map camera rotation and size constraints to a child widget tree using Flutter's \Transform.rotate\. \translucent\_pointer.dart\ adds a widget and render object that allows pointer events to pass through to subtrees while remaining invisible to parent hit testing, facilitating complex interaction layers.

lib/src/layer/shared · high confidence

The repository has been initialized with core project configuration files, including a \.firebaserc\ pointing to the \fleaflet-firebase\ project, a \firebase.json\ for hosting the example app, and \analysis\_options.yaml\ enforcing strict linting rules via \flutter\_lints\. Standard repository metadata and governance files such as \LICENSE\, \README.md\, \CHANGELOG.md\, \CODE\_OF\_CONDUCT.md\, and \CONTRIBUTING.md\ have been added, alongside \.gitignore\ and \.pubignore\ to manage build artifacts and private files.

(repo-wide) · high confidence

Added a shared state mixin and widget base class to handle projection and simplification of geometric elements (such as polylines and polygons) in map layers. This infrastructure caches projected elements and simplifies them based on camera zoom and device pixel ratio, allowing layers to reuse this logic for improved performance and consistent visual fidelity.

_lib/src/layer/shared/layer\_projection\simplification · high confidence

The example application scaffolding for leaflet\_flutter has been removed, including the Android and iOS native host files (MainActivity, AppDelegate, AndroidManifest, etc.), project configuration files (.iml, .gitignore), and the initial Flutter widget test. This cleanup eliminates obsolete boilerplate from the repository.

_leaflet\_flutter\example · high confidence

The leaflet\_flutter package has removed its initial template scaffolding, including the .gitignore, CHANGELOG, LICENSE, README, and IDE configuration files. The core library file (lib/leaflet\_flutter.dart) and its associated unit test (test/leaflet\_flutter\_test.dart) have been deleted, removing the default Calculator class and its tests. This cleanup eliminates the boilerplate code from the package.

_leaflet\flutter · high confidence

The library now exposes a single, unified entry point (\lib/flutter\_map.dart\) that re-exports all core mapping components, including the map widget, camera and controller classes, gesture handling utilities, and all layer types (Tile, Marker, Polygon, Polyline, Circle, OverlayImage, and ScaleBar). This simplifies imports for users, who can now access the entire public API by importing just this one file rather than navigating the internal \src/\ directory structure.

lib · high confidence

A change to existing behaviour in example/assets — 4 commits, 359 files.

example/assets · medium confidence · unverified

The library now includes internal implementations for HTTP date parsing and formatting (supporting RFC-1123, RFC-850, and asctime formats), an HTTP exception class, and constants for HTTP headers and status codes. These additions allow the library to handle HTTP-specific date logic and error reporting without relying on external dependencies for these core utilities.

_lib/src/dart\io · high confidence

The Android example application has been regenerated to support Flutter's V2 Android embedding. This update includes new AndroidManifest.xml files for debug, profile, and main build variants, a Kotlin-based MainActivity, and updated resource styles (including dark mode support) to align with modern Flutter Android project structures. Users running the example app on Android will benefit from compatibility with current Flutter tooling and embedding standards.

example/android · high confidence

The example application has been reorganized to showcase a broader set of features, introducing new demo pages for aborting obsolete requests, debouncing tile updates, EPSG:3996 CRS, fallback URLs, fling animation damping, interactive flags, and tile loading error handling. The app now uses Material 3 with a custom color seed and implements the path URL strategy for web navigation, while routing to existing examples like markers, polygons, circles, WMS layers, and retina mode.

example/lib · high confidence

The iOS example app project has been regenerated to support Xcode 15.1 and Swift 5. The build configuration now uses Swift for the AppDelegate instead of Objective-C, includes a bridging header, and enables GPU validation mode during debugging. A new unit test target (RunnerTests) has been added to the project structure, and the workspace references have been updated to reflect the new project location and settings.

example/ios/Runner.xcodeproj · high confidence

The marker layer has been refactored into a new \MarkerLayer\ widget and \Marker\ data class, replacing the previous implementation. This change introduces the ability to size markers using real-world meters via the \useDimensionsInMeters\ property, which calculates screen dimensions based on geographic latitude. To maintain performance with this added calculation, the layer now caches zoom-independent coordinate projections, invalidating them only when the coordinate reference system changes or the marker list is replaced. Additionally, a static \Marker.computePixelAlignment\ helper is provided to assist with calculating alignment offsets for custom marker shapes.

_lib/src/layer/marker\layer · high confidence

A new abstract \TileProvider\ base class has been introduced in \lib/src/layer/tile\_layer/tile\_provider/base\_tile\_provider.dart\. This class defines the core interface for tile loading, including support for custom HTTP headers and a new \getImageWithCancelLoadingSupport\ method that allows implementations to cancel in-flight tile requests on the web platform when tiles are disposed. It also includes utilities for populating URL template placeholders and handling tile coordinates.

_lib/src/layer/tile\_layer/tile\provider · high confidence

The map's gesture handling has been completely rewritten to support finer control over user interactions. Users can now enable or disable specific gestures—such as double-tap-drag zoom, scroll-wheel zoom, and two-finger rotation—using the new \InteractiveFlag\ enum. The scroll wheel zoom behavior has been upgraded to a smooth, C1-continuous easing animation (adapted from MapLibre GL JS), which can be customized via \ScrollZoomOptions\. Additionally, the system now exposes detailed \MapEvent\ sources (e.g., \doubleTapHold\, \scrollWheel\, \cursorKeyboardRotation\) and supports keyboard-driven map navigation with configurable damping and velocity.

lib/src/gestures · high confidence

The \lib/src/misc\ directory now contains several new internal helper classes and algorithms that support map rendering and geometry operations. This includes \IntegerBounds\ for efficient integer-coordinate bounding box calculations, \CenterZoom\ to represent a map's center and zoom level, and \OffsetHelper\ to manage coordinate transformations and offset generation for map layers. Additionally, new files introduce geometry utilities such as \isPointInPolygon\ for hit-testing, \simplify.dart\ for polyline/polygon simplification (using Ramer-Douglas-Peucker and radial distance algorithms), and \extensions.dart\ for common \Offset\, \Point\, and \Rect\ operations. These changes provide the foundational logic for improved performance and accuracy in layer drawing and interaction.

lib/src/misc · high confidence

Polygon label positioning has been refactored to use a new \PolygonLabelPlacementCalculator\ interface, replacing the deprecated \PolygonLabelPlacement\ enum. Users can now choose from four built-in algorithms—\simpleCentroid\, \simpleMultiWorldCentroid\, \centroid\ (signed area), and \polylabel\—to control where labels appear within a polygon, with the \centroid\ algorithm now being the default. This change also introduces label culling logic to prevent labels from rendering outside the visible map area and adds a \drawLabelsLast\ option to the \PolygonLayer\ to improve performance by drawing all labels on top of polygons in a single pass.

_lib/src/layer/polygon\layer · high confidence

The PolylineLayer has been restructured to support solid, dotted, and dashed line styles via the new StrokePattern configuration, allowing users to customize line appearance beyond simple solid lines. This update also introduces significant performance improvements, including cached projected bounding boxes for efficient culling, simplification caching, and optimized rendering pathways that reduce unnecessary redraws. Additionally, the layer now supports drawing polylines across world boundaries and offers a drawInSingleWorld option for specific use cases, while maintaining accurate hit detection for interactive features.

_lib/src/layer/polyline\layer · high confidence

The internal geometry layer has been restructured to improve performance and flexibility. \LatLngBounds\ is now mutable, allowing direct modification of its edge coordinates, and relies on the \latlong2\ library for coordinate types. A new \Crs\ (Coordinate Reference System) abstraction has been introduced in \crs.dart\, standardizing how map projections and transformations are handled, including support for world longitude replication. Additionally, the \LatLngBounds\ constructor now supports creating bounds wider than a single world via the \worldSafe\ factory, enabling accurate representation of features that cross the 180th meridian.

lib/src/geo · high confidence

The example app's navigation UI has been restructured to use a new drawer-based menu system. This change introduces three new files in the example's widget layer: \FloatingMenuButton\, which provides a persistent floating action button to open the navigation drawer; \MenuDrawer\, which implements the main slide-out navigation panel listing all available demo pages (such as markers, polygons, tile layers, and CRS examples) along with metadata like WASM status and commit SHA for web builds; and \MenuItemWidget\, a reusable list tile component for rendering individual navigation links. This refactoring centralizes the example app's navigation structure, replacing previous navigation patterns with a consistent drawer interface that dynamically reflects the current route and available demo features.

example/lib/widgets/drawer · high confidence

The interactivity logic for map layers has been refactored into a shared internal structure within \lib/src/layer/shared/layer\_interactivity\. This change introduces new internal classes (\HitDetectableElement\, \HitDetectablePainter\) and types (\LayerHitNotifier\, \LayerHitResult\) that standardize how hit testing is performed and reported across different layer types. For users, this underpins the ability to detect interactions with specific layer elements (like polygons or polylines) and receive structured results containing screen coordinates, geographical coordinates, and associated hit values, while maintaining backward compatibility with existing layer interaction APIs.

_lib/src/layer/shared/layer\interactivity · high confidence

The map widget's internal state management has been restructured to use a new \MapInheritedModel\ that leverages Flutter's \InheritedModel\ mechanism. This change allows descendant widgets to access the \MapCamera\, \MapController\, and \MapOptions\ with aspect-specific dependency tracking, ensuring that widgets only rebuild when the specific data they depend on changes, rather than on every state update. The \FlutterMap\ widget now wraps its content in this new inherited model, providing a more efficient and granular update cycle for map interactions.

lib/src/map · high confidence

The internal logic for determining which map tiles are visible has been restructured into a new \TileBounds\ hierarchy. This change introduces three specific bound types—\InfiniteTileBounds\, \DiscreteTileBounds\, and \WrappedTileBounds\—which handle different Coordinate Reference System (CRS) behaviors. For users, this means the tile layer now correctly calculates valid tile coordinates for maps that wrap around the world (like standard Mercator projections) or have hard geographic limits, replacing the previous generic calculation with specialized logic for each case.

_lib/src/layer/tile\_layer/tile\bounds · high confidence

The \TileLayer\ has been restructured to use a new internal architecture for handling tile rendering and lifecycle. Users will see a new \TileDisplay\ API that replaces previous fade/opacity settings, offering \instantaneous\ and \fadeIn\ modes with configurable durations and opacities. A new \TileBuilder\ callback allows customizing how individual tiles are rendered, including built-in helpers for dark mode simulation and debugging. Retina mode is now controlled via a \RetinaMode\ enum, supporting native server requests, simulation, or disabling. Tile error handling is improved with an \EvictErrorTileStrategy\ to control when failed tiles are removed from memory, and a dedicated \TileKey\ ensures stable widget identities to prevent rendering glitches.

_lib/src/layer/tile\layer · high confidence

The iOS example app has been regenerated to align with modern Flutter standards. The Info.plist now uses build variables for versioning, updates the app name to 'flutter\_map Demo', and adds keys to support indirect input events and disable minimum frame duration on phones. Additionally, the app icon asset set has been updated to include the 1024x1024 icon required for the App Store, and the project structure has been renamed from 'leaflet\_flutter\_example' to 'example'.

example/ios/Runner · high confidence

The iOS example project now includes IDEWorkspaceChecks.plist and WorkspaceSettings.xcsettings to configure Xcode workspace behavior. Specifically, the workspace is set to disable the 32-bit warning and disable previews, ensuring consistent build environment settings for the example app.

example/ios/Runner.xcworkspace/xcshareddata · high confidence

The Windows Flutter example project now includes a new CMakeLists.txt file that configures the Flutter library and C++ wrapper builds, alongside generated files (generated\_plugin\_registrant.cc/h and generated\_plugins.cmake) that explicitly register the url\_launcher\_windows and jni plugins. This ensures the Windows build correctly links and initializes these specific plugins during runtime.

example/windows/flutter · high confidence

The iOS example application now requires iOS 13.0 or later to run. This change is enforced by updating the MinimumOSVersion in the AppFrameworkInfo.plist and removing the explicit arm64 device capability requirement, reflecting a shift in the supported iOS base version for the example project.

example/ios/Flutter · high confidence

Added iOS unit test scaffold; Added micro-benchmarks for CRS, point-in-polygon, and feature layers; Added test coverage for CRS scale/zoom edge cases and LatLngBounds geometry; Added test helper utilities for generating random data; Added test utilities for FlutterMap integration testing; Added tests for CameraConstraint.containLatitude; Added tests for NetworkTileImageProvider behavior; Added tests for TileBounds and TileBoundsAtZoom logic; Added tests for fling direction fallback and scroll wheel zoom behavior; Added tests for map controller camera fitting and zero-size layout handling; Added tests for point-in-polygon logic and PositionedTapDetector2 coordinate handling; Added unit tests for TileImageView and TileRange logic; Added unit tests for the Bounds class; Added widget tests for map layer rendering and keys; Initial integration and coverage tests for flutter\_map.

The example application's Android build configuration has been migrated from Groovy to Kotlin DSL (build.gradle.kts), upgrading the Android Gradle Plugin to 8.11.1 and Kotlin to 2.2.20, while setting Java compatibility to version 17. The main library and example \pubspec.yaml\ files have been updated to require Dart SDK \>=3.6.0 and Flutter \>=3.27.0, with dependency bumps for \flutter\_lints\ (up to 6.0.0), \http\ (to 1.6.0), and \proj4dart\ (to 3.0.0). The legacy \leaflet\_flutter\ package and its example project have been removed.

(dependencies) · high confidence

The example Android application now uses Gradle 8.14 instead of the previous version 3.3. This upgrade ensures the example app builds with a modern, supported version of the Gradle build tool, which may affect build performance and compatibility with newer Android plugin versions.

example/android/gradle · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 55 → 63 (+7.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 97 → 87 (-10.2)
• Architecture 98 → 99 (+0.4)
• Maturity 46 → 46 (+0.3)
• Readiness 56 → 67 (+11.8)
• Security 48 → 78 (+30.4)
• Domain Modelling 100 → 100 (+0.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 20 more

• BuiltInMapCachingProviderImpl.getTile (cognitive 21) (lib/src/layer/tile_layer/tile_provider/network/caching/built_in/impl/native/native.dart)
• BuiltInMapCachingProviderImpl.getTile (cognitive 21) (lib/src/layer/tile_layer/tile_provider/network/caching/built_in/impl/stub.dart)
• CirclePainter.paint (cognitive 28) (lib/src/layer/circle_layer/painter.dart)
• ClassTooLong: MapControllerImpl (lib/src/map/controller/map_controller_impl.dart)
• ClassTooLong: MapInteractiveViewerState (lib/src/gestures/map_interactive_viewer.dart)
• DashedPixelHiker.getAllVisibleSegments (cognitive 38) (lib/src/layer/shared/line_patterns/pixel_hiker.dart)
• DashedPixelHiker.getAllVisibleSegments (cyclomatic 17) (lib/src/layer/shared/line_patterns/pixel_hiker.dart)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: contradicts the code (example/tool/geojson/README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (example/README.md)
• DottedPixelHiker.getAllVisibleDots (cognitive 19) (lib/src/layer/shared/line_patterns/pixel_hiker.dart)
• Duplicated block (10 lines × 2) (lib/src/layer/polygon_layer/polygon_layer.dart)
• Duplicated block (11 lines × 2) (example/lib/pages/markers.dart)
• Duplicated block (12 lines × 2) (example/lib/pages/abort_obsolete_requests.dart)
• Duplicated block (14–15 lines × 3) (example/lib/pages/polygon.dart)
• Duplicated block (15 lines × 2) (example/lib/pages/polygon.dart)
• Duplicated block (15–16 lines × 2) (example/lib/pages/polygon.dart)
• Duplicated block (15–16 lines × 2) (lib/src/map/camera/camera_fit.dart)
• Duplicated block (16 lines × 3) (example/lib/pages/polygon.dart)
• …and 126 more

• 9 commits — 6 feature/other, 3 fixes

• .github/workflows — 3 commits
• example/lib — 3 commits
• lib/src — 2 commits
• (root) — 1 commit

• fix: chore(meta): fix CI/CD (#2248)
• fix: fix: prefer imports from 'pkg:flutter/widgets.dart' instead of 'material' (#2254)
• fix: fix: prevent RangeError in Proj4Crs.scale/zoom for out-of-range values (#2209)
• change: chore(deps): bump actions/setup-java from 5 to 6 (#2247)
• change: chore(deps): bump actions/stale from 10 to 11 (#2238)
• change: chore(example): prepare for upgrade to built-in Kotlin (#2252)
• change: chore: prepare for v8.3.2 release (#2245)
• change: feat: add ability to use meters to size Markers (#2106)
• change: feat: add smooth scroll zooming (#2198)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

fleaflet/flutter_map was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.