Skip to content
CAI
Software that uses CAICheck a score

Milad-Akarie/auto_route_library

63.2

Adequate · 17 November 2026

14.2k

lines of production code

Dart

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is a Flutter routing library that provides declarative navigation, deep linking, and route guarding across mobile, web, and desktop platforms. It features a refactored core with immutable configuration, platform-specific history management, and support for predictive back gestures and nested tab navigation. The ecosystem includes a code generator that produces route definitions from annotations, alongside comprehensive examples demonstrating authentication flows, data models, and complex UI layouts.

How it got here

2019–2020 — Declarative routing and generator overhaul

20 changes.

The project underwent a major architectural shift to a declarative routing model, introducing new widgets like AutoRouter and AutoTabsRouter alongside a redesigned routing controller. The code generation system was completely rewritten, replacing the legacy annotation package with a new generator that supports deferred loading and improved argument handling. This period also involved significant dependency upgrades and cleanup of legacy boilerplate across the library and example projects.

2021 — Declarative routing and platform support

21 changes.

The project introduced a declarative routing API and refactored the generator's internal models to support complex route configurations and Dart records. Significant platform enhancements included native support for Android predictive back gestures and a new provider to fix browser history synchronization issues. The example application was comprehensively updated to demonstrate these new patterns across mobile, web, and iOS platforms.

2022–2025 — Web support and generation improvements

13 changes.

This period focused on enhancing platform-specific capabilities, notably introducing true browser history support for web and adding comprehensive authentication guard examples. The code generation system was modernized with a new lean builder pipeline and configurable output extensions, while test coverage was expanded for nested routing and generation logic.

Features

Add book list and details screens to the example app

The example application now includes a book browsing feature. A new BookListScreen displays a list of books from the local database, and tapping a book navigates to a BookDetailsPage that shows the book's information and a read counter. This adds a concrete navigation flow to the mobile example, demonstrating route parameters and result passing.

_auto\route/example/lib/mobile/screens/books · high confidence

Add declarative navigation example app

The example application now includes a declarative navigation demo in the \lib/declarative\ directory. This example demonstrates how to use \AutoRouter.declarative\ to dynamically control the route stack based on application state (specifically a \ValueNotifier\ tracking user profile data), showing a multi-step flow where screens are added or removed conditionally.

_auto\route/example/lib/declarative · high confidence

Add example data models and providers for books and users

The example application now includes a new data layer (\db.dart\) that defines \Book\ and \User\ models along with their respective in-memory databases (\BooksDB\, \UsersDB\). These are exposed to the UI via \InheritedWidget\ providers (\BooksDBProvider\, \UsersDBProvider\), enabling the example app to access and display sample book and user data.

_auto\route/example/lib/data · high confidence

Add example project demonstrating no-code generation approach

The example project now includes a main.dart file that sets up an AppRouter using the @AutoRouterConfig annotation and extends RootStackRouter. This demonstrates a manual configuration approach where routes are defined directly in code rather than relying on code generation, providing a reference for users who prefer a no-code-gen strategy.

_auto\_route\generator/example · high confidence

Add nested navigation example using declarative routing

The nested-navigation example now demonstrates a declarative routing setup, introducing a \NestedRouter\ that manages a host screen with nested child routes (\FirstScreen\ and \SecondScreen\). The example includes the generated route definitions (\nested\_navigation.router.gr.dart\) and uses \AutoLeadingButton\ for automatic back-button handling within the nested stack, illustrating how to structure and navigate complex, multi-level route hierarchies.

_auto\route/example/lib/nested-navigation · high confidence

Add profile screen and route configuration to example app

The example application now includes a new Profile section, featuring a ProfilePage with navigation controls (such as navigating to My Books, toggling settings, and replacing routes) and a new MyBooksPage that displays a filter query parameter and supports deep-linking to settings. These screens are wired into the routing system via a new profileRoute definition that maps the 'profile' path to the ProfileTab, which contains nested routes for the profile home and my-books views.

_auto\route/example/lib/mobile/screens/profile · high confidence

Add user-data example screens for declarative routing

The example app now includes a new 'user-data' screen set (data\_collector.dart, routes.dart, single\_field\_page.dart, user\_data\_collector\_page.dart, user\_data\_page.dart) that demonstrates declarative routing with AutoRouter.declarative. These screens use a ChangeNotifierProvider to manage user input state (name and favorite book) and show how to navigate between single-field input pages and a results page within a nested route structure.

_auto\route/example/lib/mobile/screens/user-data · high confidence

Add web demo with authentication guard example

A new web demonstration application has been added to the example project, showcasing how to implement route guards using the \AutoRouteGuard\ interface. The demo includes a \LoginPage\ and an \AuthService\ that manages authentication and verification states, allowing users to test how the router handles protected routes and redirects based on user login status.

_auto\_route/example/lib/web\demo · high confidence

Added web entry point and PWA manifest for the example app

The example application now includes the necessary files to run as a web application and Progressive Web App (PWA). A new \index.html\ file serves as the entry point, configuring the page title, base href, and registering a service worker for offline capabilities. Additionally, a \manifest.json\ file defines the app's metadata, including its name, display mode (standalone), theme colors, and icon assets, enabling proper installation and presentation on mobile and desktop browsers.

_auto\route/example/web · high confidence

Introduce lean\_builder code generation for AutoRouter

This change adds a new code generation pipeline using the \lean\_builder\ package to produce AutoRouter implementations. It introduces \LeanAutoRouteBuilder\ to scan for \@RoutePage\ annotations and emit intermediate \.route.ln.json\ configuration files, and \LeanAutoRouterBuilder\ to consume those JSON files and generate the final \.gr.dart\ router source code. The included resolvers handle route configuration, parameter resolution (including stripping leading underscores from parameter names and handling \dart:\ imports), and router config extraction, providing a new, leaner alternative for generating routing code.

_auto\_route\_generator/lib/src/lean\builder · high confidence

Introduces declarative routing helpers and a new AutoRoutePage implementation

This change adds a new \AutoRoutePage\ class that serves as the central page factory, handling route creation for Material, Cupertino, Custom, and Adaptive route types while supporting predictive back gestures and state management flags. It also introduces the \AutoRouterX\ extension on \BuildContext\, providing convenient helper methods like \pushRoute\, \replaceRoute\, \navigateTo\, and \back\ to simplify navigation calls from UI code.

_auto\route/lib/src/router · high confidence

Introduces mobile example app with declarative routing and auth guard

The mobile example application is now bootstrapped using a declarative routing configuration. It integrates an authentication guard to protect routes and utilizes the Provider package to manage application state (AuthService and BooksDB) within the widget tree. The app is configured with a light theme and includes an AutoRouteObserver for tracking navigation changes.

_auto\route/example/lib/mobile · high confidence

Introduces new declarative routing widgets and tab navigation components

This change adds a suite of new widgets to the routing library to support declarative routing and enhanced tab navigation. It introduces \AutoRouter\ and \AutoRouteNavigator\ to handle stack-based navigation with declarative route lists, \AutoTabsRouter\ (with \IndexedStack\, \PageView\, \TabBar\, and \Builder\ variants) for parallel routing, and \AutoTabsScaffold\ for scaffolding tabbed interfaces. Additionally, it adds \AutoLeadingButton\ to replace the default back button with one that respects the full route hierarchy, \AutoTabView\ and \AutoPageView\ for tab-specific page views, \DeferredWidget\ for lazy-loading routes, and \CustomCupertinoTransitionsBuilder\ to fix shadow issues in nested Cupertino routes.

_auto\route/lib/src/router/widgets · high confidence

New common library for annotations, observers, and utilities

This change introduces a new \common\ library that consolidates core routing primitives. It adds \AutoRouterConfig\ and \RoutePage\ annotations to configure route generation, including options for deferred loading and argument equality. It provides \AutoRouteObserver\ and \AutoRouteAware\ to monitor route lifecycle events, including tab-specific changes, and includes a \AutoRouteAwareStateMixin\ to reduce boilerplate. Additionally, it introduces a \Parameters\ class for typed access to path and query parameters, \AutoRouteWrapper\ for wrapping route widgets, and \TransitionsBuilders\ for common route animations.

_auto\route/lib/src/common · high confidence

Support for Android predictive back gestures and custom page transitions

The library now includes native support for Android's predictive back gesture via a new \\_PredictiveBackPageDetector\ that integrates with the routing lifecycle, ensuring correct handling of back-swipe animations and state. Additionally, a new \AutoPageRouteBuilder\ class is introduced, allowing developers to push arbitrary widgets with custom transition builders and configurable properties like \opaque\ and \transitionDuration\, providing greater flexibility over page animations compared to the previous default behavior.

_auto\route/lib/src/router/transitions · high confidence

Web demo adds authentication guards and path state management

The web demo example now includes a complete authentication flow using the \AuthGuard\ and \VerifyGuard\ to protect routes, requiring users to log in and verify their identity before accessing protected content. Additionally, the demo showcases the \pushPathState\ and \pathState\ APIs, allowing the main page to manage and display navigation state updates.

_auto\_route/example/lib/web\demo/router · high confidence

Removals

Removal of auto\_route\_annotation package

The auto\_route\_annotation package has been completely removed from the codebase. This deletion eliminates the package's build-time code generation capabilities, including the route collector, route generator, and router class generator that previously produced .auto\_route.dart and .router.dart files. Users relying on this package for automatic route generation will no longer have access to these generated artifacts.

_auto\_route\annotation · high confidence

Removed example application files

The example application located in \example/lib\ has been removed. This includes the main entry point (\main.dart\), the generated router configuration (\main.router.dart\), and the specific route screen widgets (\home.dart\, \login.dart\, \products\_details.dart\).

example/lib · high confidence

Behavioural changes

Added iOS native integration and LLDB debugging support files

The example iOS project now includes generated files to support native integration and debugging. A new \.swift\_pm.lock\ file manages Swift Package Manager dependencies, while \flutter\_native\_integration.env\ provides environment variables for the build process. Additionally, \flutter\_lldb\_helper.py\ and \flutter\_lldbinit\ are added to enable LLDB script integration, allowing developers to intercept memory page notifications and simplify debugging of the native runtime.

_auto\route/example/ios/Flutter/ephemeral · high confidence

Added iOS workspace configuration files for the example app

The example app now includes standard Xcode workspace configuration files (contents.xcworkspacedata, IDEWorkspaceChecks.plist, and WorkspaceSettings.xcsettings) for both the project-level and top-level workspace directories. These changes ensure consistent workspace settings, such as disabling previews, and resolve potential Xcode workspace warnings for developers cloning or opening the example project.

_auto\_route/example/ios/Runner.xcodeproj/project.xcworkspace, auto\route/example/ios/Runner.xcworkspace · high confidence

Example app adopts declarative routing with guarded nested routes

The mobile router example has been refactored to use the declarative routing API, replacing the previous configuration style. The new \AppRouter\ defines a nested structure where the \BookDetailsRoute\ is protected by an \onNavigation\ guard that checks an \AuthService\ to redirect unauthenticated users to the login page. The generated code (\router.gr.dart\) now includes specific route classes and argument models for the books, login, and profile screens, reflecting the updated route definitions and parameter handling.

_auto\route/example/lib/mobile/router · high confidence

Example project restructured with updated tooling configuration

The example project has been reorganized into the auto\_route/example directory and updated with modern Flutter tooling configurations. A new .gitignore file excludes standard build artifacts and IDE files, while analysis\_options.yaml enforces linting rules via flutter\_lints. Configuration files for build\_runner (build.yaml), DevTools (devtools\_options.yaml), and Flutter metadata (.metadata) have been added to support code generation and platform-specific settings.

_auto\route/example · high confidence

Generator renamed from auto\_route\_annotation to auto\_route\_generator with updated build configuration

The code generation package has been renamed from \auto\_route\_annotation\ to \auto\_route\_generator\. This change includes a new \build.yaml\ configuration that defines two distinct build steps: a primary \auto\_route\_generator\ builder that outputs \.route.json\ files to the cache, and a secondary \auto\_router\_generator\ builder that produces the final \.gr.dart\ source files. The package also introduces a \LICENSE\ file (MIT), updates \analysis\_options.yaml\ to enforce public API documentation, and adds \pubspec.lock\ to the \.gitignore\.

_auto\_route\generator · high confidence

The library now includes a new \DefaultRouteParser\ implementation that extends Flutter's \RouteInformationParser\. This parser introduces a \deepLinkTransformer\ callback, allowing users to intercept and modify incoming deep-link URIs before they are matched against routes, which is particularly useful for handling platform-specific path prefixes on Android or Apple. Additionally, it adds an \includePrefixMatches\ configuration option (defaulting to false) to control whether prefix-matched paths are included in the matching list, and supports URL fragments. The parser also utilizes a new \AutoRouteInformation\ class to support replacing the current browser history entry via a \replace\ flag, and structures the parsed state into a \UrlState\ object containing URI, route segments, and path state.

_auto\route/lib/src/router/parser · high confidence

Introduce new model classes for route generation configuration

The generator now uses a new set of data models in \auto\_route\_generator/lib/src/models\ to represent route and router configuration. \ResolvedType\ handles type resolution including Dart record support, while \RouteConfig\ and \ParamConfig\ (including \FunctionParamConfig\) define route paths, parameters, and argument structures. \RouterConfig\ manages global router settings such as deferred loading and part builder usage, and \RoutesList\ aggregates the route definitions. These models support serialization to JSON for caching and build optimization.

_auto\_route\generator/lib/src/models · high confidence

Introduces cached build support and configurable output extensions for route generation

The generator now supports an optional caching mechanism to speed up builds by skipping unchanged files, controlled via the \enable\_cached\_builds\ configuration option. Additionally, the output file extension for generated route files is no longer hardcoded to \.gr.dart\; it is now configurable via the \generatedExtension\ option, allowing users to customize the suffix of generated files.

_auto\_route\generator/lib/src/builders · high confidence

Introduces navigation failure types and utility helpers

The library now exposes a \NavigationFailure\ abstraction with two concrete implementations: \RouteNotFoundFailure\ for missing routes and \RejectionByGuardFailure\ for guard-denied navigation, along with an \OnNavigationFailure\ callback signature for handling these events. Additionally, internal utility functions for map emptiness checks, kebab-case conversion, and conditional throwing have been added to support the refactored routing logic.

_auto\route/lib/src · high confidence

Introduces new RouteMatch and RouteMatcher classes for path resolution

The library now uses a dedicated \RouteMatch\ class to represent the result of a route match, exposing extracted path parameters, query parameters, URL fragments, child matches, and route configuration details (such as guards, meta, and flags like \fullscreenDialog\). A new \RouteMatcher\ class handles the core logic of matching URIs and \PageRouteInfo\ objects against the route collection, supporting prefix matches, redirect handling, and nested route resolution. This refactors how the router identifies and structures matched routes internally.

_auto\route/lib/src/matcher · high confidence

New utility helpers and builder entry points for route generation

The generator now exposes dedicated builder entry points (\autoRouterBuilder\ and \autoRouteBuilder\) in \builder.dart\ to initiate code generation, alongside new utility files (\build\_utils.dart\ and \utils.dart\) that provide error-throwing helpers, Dart type name extraction, and string manipulation functions like kebab-case conversion. These changes establish the foundational infrastructure for the generator's build process, enabling more robust error handling and consistent naming conventions for generated route paths.

_auto\_route\generator/lib · high confidence

Platform-specific navigation history implementation

The navigation history management has been refactored to use distinct implementations for web and native platforms. On web, the router now directly interacts with the browser's \window.history\ API to support true forward/back navigation and state management. On native platforms, a local in-memory stack is used to mimic browser history behavior, limiting entries to 20 and preventing duplicates. This change ensures that navigation history accurately reflects the underlying platform's capabilities, with web users gaining access to native browser history features while native users retain a consistent, albeit simulated, history stack.

_auto\_route/lib/src/router/controller/navigation\history · high confidence

Redesigned mobile navigation and routing examples

The mobile example application has been updated to demonstrate the latest declarative routing patterns. The home screen now uses a conditional layout: web clients use a NavigationRail with an AutoRouter builder to track active routes, while mobile clients use an AutoTabsRouter with a BottomNavigationBar that can be dynamically hidden based on route metadata. New screens include a WelcomeScreen utilizing the AutoLeadingButton builder and a LoginPage with configurable back-button visibility. The Settings screen now explicitly handles path and query parameters using annotations and implements the AutoRouteAwareStateMixin to react to tab route changes, providing a concrete example of parameter handling and lifecycle management.

_auto\route/example/lib/mobile/screens · high confidence

Redesigned routing controller with declarative API and scoped navigation

The routing controller has been refactored to support a declarative routing model, introducing new scope-based widgets (RouterScope, StackRouterScope, TabsRouterScope) that inject controllers into the widget tree for easier lookup. The core navigation logic now relies on a unified NavigationResolver and AutoRouteGuard system, allowing guards to resolve navigation events asynchronously and re-evaluate based on listenable state. Deep-link handling has been enhanced with a configurable DeepLinkBuilder and DeepLinkTransformer, giving users the ability to validate, abort, or override platform links before navigation occurs. Additionally, the delegate now supports rebuilding the entire route stack on deep-link events via the rebuildStackOnDeepLink flag, and pageless routes are tracked via a dedicated PagelessRoutesObserver to improve back-gesture and navigation history behavior.

_auto\route/lib/src/router/controller · high confidence

Refactor routing core to use immutable configuration and new PageInfo abstraction

The routing core in \auto\_route/lib/src/route\ has been refactored to use immutable configuration objects and a new \PageInfo\ abstraction. \AutoRoute\ is now an immutable class with a \copyWith\-style factory (\\_change\) and a dedicated \guarded\ constructor, replacing previous mutable patterns. Route definitions now rely on \PageInfo\ to hold page builders and names, which simplifies the generated route types (\PageRouteInfo\) and allows for const empty shells. This change introduces \RouteDataScope\ for context-based route data lookup, updates \RouteType\ to support predictive back gestures and \Duration\-based transition timings (deprecating integer milliseconds), and ensures that route equality checks respect the new \argsEquality\ configuration.

_auto\route/lib/src/route · high confidence

Refactored code generation to support deferred loading and improved argument equality

The code generator in the \code\_builder\ directory has been rewritten to use the \code\_builder\ package, introducing a \DeferredPagesAllocator\ that enables deferred loading for web routes to support code splitting. The generated route info classes now include an optional \argsEquality\ configuration; when enabled (default), argument classes implement \==\ and \toString\ using \ListEquality\, \SetEquality\, and \MapEquality\ from the \collection\ package to ensure correct identity checks for complex types. Additionally, the generator now supports URL fragment parameters and ensures that routes with deferred loading are correctly handled even if not explicitly marked, while preventing incompatible combinations with the part-file approach.

_auto\_route\_generator/lib/src/code\builder · high confidence

Refactored route configuration and parameter resolution logic

The resolver layer in auto\_route\_generator has been restructured into four dedicated classes: RouteConfigResolver, RouteParameterResolver, RouterConfigResolver, and TypeResolver. This change introduces stricter validation for route parameters, such as enforcing that query parameters and URL fragments are nullable or have default values, and ensuring path parameters are of valid string-parseable types. It also adds support for resolving Dart record types in type arguments and improves import path resolution for assets and packages. Users will see more precise compile-time errors for misconfigured route parameters and better handling of complex type structures in generated code.

_auto\_route\generator/lib/src/resolvers · high confidence

Release v11.2.0 with package hygiene and migration to material\_ui/cupertino\_ui

The auto\_route package is updated to version 11.2.0, which includes a migration to the \material\_ui\ and \cupertino\_ui\ packages. This release also improves the development experience by adding a \.pubignore\ file to exclude test files, build artifacts, and coverage reports from published packages, and introduces a \run\_coverage\ script to easily generate HTML coverage reports. Additionally, the package license is now explicitly set to MIT, and analysis options are configured to enforce public API documentation.

_auto\route · high confidence

Removal of legacy Android Flutter boilerplate files

The example Android project has removed several files associated with older Flutter project structures, including the \.metadata\ file, the \MainActivity.kt\ (which previously extended \FlutterActivity\ and manually registered plugins), and the \AndroidManifest.xml\ files for debug, profile, and main configurations. This cleanup suggests a migration to a newer Flutter tooling standard or project template where these legacy artifacts are no longer required or are managed differently.

example/android · medium confidence

Removed generated iOS environment script

The generated \flutter\_export\_environment.sh\ file in the iOS example project has been removed. This file previously contained hardcoded build environment variables such as the Flutter root, application path, and build directory settings. Its removal indicates a shift in how the iOS build environment is configured or managed for the example app, likely relying on standard Flutter tooling to inject these values at build time rather than maintaining a static script.

example/ios · high confidence

Reworked public API surface and removed legacy annotations

The library's public exports have been consolidated into a single \auto\_route.dart\ entry point, replacing the previous separate \route\_gen\_annotation.dart\ and \router\_annotation.dart\ files. This change removes the legacy \AutoRoute\ and \RouterApp\ annotation classes, signaling a breaking shift in how routes are declared and configured, while exposing a broader set of internal components such as the routing controller, information provider, and various router widgets.

_auto\route/lib · high confidence

Update macOS ephemeral build configuration files

The macOS example project's ephemeral build configuration files have been updated. This includes the addition of a new GeneratedPluginRegistrant.swift file, a .swift\_pm.lock file, and updates to Flutter-Generated.xconfig, flutter\_export\_environment.sh, and flutter\_native\_integration.env to reflect the current build environment and paths.

_auto\route/example/macos · medium confidence

Updated Android example project build configuration

The Android example project has been upgraded to use the NDK version 26.3.11579264 and CMake 3.22.1, with the minimum SDK target set to android-21. Additionally, a .gitignore file was added to the Android directory to exclude build artifacts, Gradle wrappers, and sensitive keystore files from version control.

_auto\route/example/android · high confidence

Updated iOS Xcode scheme for Flutter Runner

The iOS build scheme for the example app has been updated to version 1.3 with a last upgrade version of 1510. This change configures the build, test, launch, profile, analyze, and archive actions to target the Runner.app, enabling GPU validation mode during launch and ensuring the app is built for testing, running, profiling, archiving, and analyzing.

_auto\route/example/ios/Runner.xcodeproj/xcshareddata · high confidence

Updated iOS project configuration for the auto\_route example app

The Xcode project file for the auto\_route example application has been regenerated to reflect the current Flutter tooling standards. This update ensures the iOS build configuration is compatible with recent Flutter versions, supporting the library's example project stability and build process.

_auto\route/example/ios/Runner.xcodeproj · medium confidence

iOS Runner updated for modern entry points and deep linking support

The iOS example app's entry point has been updated to use the modern @main attribute, and the Info.plist has been configured to enable Flutter deep linking via a custom URL scheme (customscheme) and to disable minimum frame duration on iPhone. Additionally, the app now supports indirect input events, and the bridging header was updated to ensure a proper newline at the end of the file.

_auto\route/example/ios/Runner · high confidence

Fixes

Add AutoRouteInformationProvider to fix infinite browser back button and URL update issues

A new \AutoRouteInformationProvider\ class has been added to handle platform route information synchronization. This provider ensures that route changes are correctly reported to the browser engine via \SystemNavigator.routeInformationUpdated\ and \selectMultiEntryHistory\, which fixes the infinite browser back button loop that occurred during URL redirects and resolves delays in URL updates. It also addresses issues where routes with empty paths failed to update the URL and fixes a crash related to the \routerReportsNewRouteInformation\ method's required 'type' argument.

_auto\route/lib/src/router/provider · high confidence

Added Linux Flutter plugin registration stubs

The Linux example application now includes the generated plugin registrant files (C source, header, and CMake configuration). These files provide the necessary infrastructure for registering Flutter plugins on the Linux platform, ensuring the example app is correctly configured to support plugin-based features in this environment.

_auto\route/example/linux · high confidence

Updated iOS Flutter build configuration and metadata

The iOS example project's Flutter build infrastructure has been updated. The AppFrameworkInfo.plist now sets the minimum supported iOS version to 13.0, and the build configuration files (Debug.xcconfig and Release.xcconfig) have been standardized to include the necessary Pods and Generated config files, ensuring consistent build settings for the example app.

_auto\route/example/ios/Flutter · high confidence

Test coverage

Added test file for router generation; Added tests for declarative and nested router behaviors; Added tests for simple router navigation and observer behavior; Added unit tests for AutoRoute annotations, observers, and navigation history; Added widget tests for nested tabs router configurations; Removed legacy widget test.

Dependencies

Major dependency and build system upgrades across the AutoRoute library

The AutoRoute packages have been upgraded to require Dart SDK 3.0.0+ and Flutter 3.16.0+, with the generator (\auto\_route\_generator\) targeting Dart 3.4.0+. Key dependency updates include \analyzer\ (constrained to 10.0.0–14.0.0), \source\_gen\ (3.1.0–5.0.0), \build\ (3.0.2–5.0.0), \dart\_style\ (3.1.5), and \code\_builder\ (4.11.1). The example project has been migrated to the new Android Gradle Plugin (AGP) 8.8.1 and Kotlin 2.1.0, replacing the legacy \apply plugin\ syntax with the plugins block and updating \compileSdk\ to 34. Additionally, the \auto\_route\_annotation\ package has been removed, and the example now uses \flutter\_lints\ and \provider\.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 57.5 → 63.2 (+5.7)
  • Rubric changed (rubric-2026.11.2 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 91.6 → 90.4 (-1.2)
  • Architecture 87.7 → 88.6 (+0.9)
  • Maturity 45.8 → 58.1 (+12.3)
  • Readiness 58.6 → 58.5 (-0.1)
  • Security 100.0 → 100.0 (0.0)
  • Performance 60.0 → 60.0 (0.0)

Resolved (2)

  • Duplicated block (11 lines × 2) (auto_route_generator/lib/src/lean_builder/resolvers/lean_type_resolver.dart)
  • Projects may be oversized for their cohesion

New (22)

  • Documentation: no build, run or usage example (auto_route_generator/README.md)
  • Edited copies of one member (3 members, 19+ corresponding lines) (auto_route/example/lib/declarative/declarative.router.dart)
  • Edited copies of one member (3 members, 31+ corresponding lines) (auto_route/lib/src/router/widgets/auto_router.dart)
  • Edited copies of one member (4 members, 10+ corresponding lines) (auto_route/lib/src/common/transitions_builders.dart)
  • Edited copies of one member (4 members, 8+ corresponding lines) (auto_route/lib/src/router/widgets/auto_tabs_router.dart)
  • Edited copy of a member (11 corresponding lines) (auto_route/lib/src/router/widgets/auto_leading_button.dart)
  • Edited copy of a member (11 corresponding lines) (auto_route/lib/src/router/widgets/auto_page_view.dart)
  • Edited copy of a member (14 corresponding lines) (auto_route/example/lib/web_demo/router/web_login_page.dart)
  • Edited copy of a member (14 corresponding lines) (auto_route/lib/src/router/widgets/custom_cupertino_transitions_builder.dart)
  • Edited copy of a member (14 corresponding lines) (auto_route_generator/lib/src/lean_builder/resolvers/lean_route_parameter_resolver.dart)
  • Edited copy of a member (16 corresponding lines) (auto_route/lib/src/router/controller/routing_controller.dart)
  • Edited copy of a member (16 corresponding lines) (auto_route/lib/src/router/widgets/auto_page_view.dart)
  • Edited copy of a member (16 corresponding lines) (auto_route/lib/src/router/widgets/auto_tabs_router.dart)
  • Edited copy of a member (17 corresponding lines) (auto_route/lib/src/router/widgets/auto_tabs_router.dart)
  • Edited copy of a member (19 corresponding lines) (auto_route/lib/src/router/widgets/auto_page_view.dart)
  • Edited copy of a member (24 corresponding lines) (auto_route/lib/src/router/controller/routing_controller.dart)
  • Edited copy of a member (33 corresponding lines) (auto_route/lib/src/router/widgets/auto_tabs_router.dart)
  • Edited copy of a member (43 corresponding lines) (auto_route_generator/lib/src/lean_builder/resolvers/lean_type_resolver.dart)
  • Edited copy of a member (7 corresponding lines) (auto_route/lib/src/router/controller/controller_scope.dart)
  • Edited copy of a member (9 corresponding lines) (auto_route/lib/src/router/widgets/auto_page_view.dart)
  • …and 2 more

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

Survey your own repository

Milad-Akarie/auto_route_library 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.

About this page

  • The score is its most recent published measurement, taken on 17 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 1505c67a42466bb929c2ad833c5b15d67b94b2f9 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.85+preprod-eba6548ac50f.