jonataslaw/getx

This system is a comprehensive Flutter framework providing state management, dependency injection, and navigation capabilities. It offers a modular architecture with distinct modules for reactive state management, HTTP and WebSocket connectivity, and a modern routing system supporting nested navigation and route guards. The library also includes utility functions, internationalization support, and a suite of example applications demonstrating these features across multiple platforms.

49 changes.

This period focused on restructuring the GetX library into a modular, multi-package architecture with distinct entry points for navigation, state management, and utilities. A major addition was the introduction of GetConnect, a comprehensive HTTP and WebSocket client with interceptor and multipart support. The example application was also significantly updated to demonstrate these new capabilities, including modernized UI and navigation patterns.

35 changes.

This period focused on building a comprehensive 'Navigation 2.0' example application that demonstrates nested routing, lazy dependency injection, and authentication middleware. Concurrently, the core Snackbar component was completely rewritten to support message queuing, animations, and improved memory management.

4 changes.

This period focused on enhancing platform-specific capabilities, introducing a new HTTP request abstraction that supports both browser and server environments. Additionally, a comprehensive animation library was added, providing a suite of pre-built animations and a builder widget to simplify their application in Flutter applications.

Introduced the GetConnect class, a new HTTP client implementation that provides methods for GET, POST, PUT, PATCH, and DELETE requests, as well as GraphQL query and mutation support. The implementation includes configurable options such as timeout, user agent, redirect handling, and proxy settings. Additionally, new exception classes (GetHttpException, GraphQLError, UnauthorizedException, UnexpectedFormat) are added to handle various error states.

_lib/get\connect · high confidence

The example application now initializes with a GetMaterialApp that explicitly binds the AuthService and configures the initial route and page routes. This sets up the foundational structure for the navigation system, including commented-out code for a splash screen and route information parsing, indicating a shift toward a more explicit dependency injection and routing setup.

_example\nav2/lib · high confidence

Added a new HTML-specific HTTP client implementation (lib/get\_connect/http/src/http/html) that uses XMLHttpRequest to handle HTTP requests on the web platform. The implementation supports configurable withCredentials, handles response headers, and provides a complete client interface for web-based HTTP communication.

_lib/get\connect/http/src/http/html · high confidence

A new factory function \createHttp\ is introduced in the HTTP request module, serving as a platform-aware entry point that delegates to either the HTML or IO implementation of \HttpRequestImpl\. This change enables the library to support multiple execution environments (browser vs. server) by selecting the appropriate underlying HTTP client based on the Dart library available at runtime.

_lib/get\connect/http/src/http/request · high confidence

A new \HttpStatus\ class has been introduced to provide a comprehensive set of HTTP status code constants (e.g., \ok\, \notFound\, \internalServerError\) along with helper methods for common checks such as \isOk\, \hasError\, and \isServerError\. This allows users to easily reference and validate HTTP status codes in their applications.

_lib/get\connect/http/src/status · high confidence

Added a new README-hi.md file containing the Hindi translation of the GetX documentation, expanding the library's multilingual support to include Hindi-speaking developers.

(repo-wide) · high confidence

The library now includes platform-specific implementations for HTTP requests and file decoding. For the IO (server-side/Flutter) environment, new files (\http\_request\_io.dart\, \file\_decoder\_io.dart\) provide concrete implementations of HTTP headers, response handling, and file-to-bytes conversion. These are paired with corresponding stubs (\http\_request\_stub.dart\, \file\_decoder\_stub.dart\) that throw \UnimplementedError\, ensuring the codebase compiles on non-IO platforms like the web. This change enables the HTTP client to function correctly in IO-based environments while maintaining compatibility with other platforms.

_lib/get\connect/http/src/http/io · high confidence

GetConnect now supports real-time communication via WebSockets. This change introduces a new \BaseWebSocket\ abstraction with platform-specific implementations for the browser (\sockets\_html.dart\) and the Dart VM (\sockets\_io.dart\), along with a stub for unsupported environments. Users can now establish persistent, bidirectional connections to servers, subscribe to message, error, and close events, and send data in real-time. The implementation includes a \SocketNotifier\ to manage event listeners and supports self-signed certificates for server-side connections.

_lib/get\connect/sockets/src · high confidence

The bottom sheet implementation now supports a \curve\ property, allowing users to define a custom animation easing for the bottom sheet's entrance and exit transitions. This change introduces a new parameter to the bottom sheet route, enabling more control over the visual feel of the modal bottom sheet's animation.

_lib/get\navigation/src/bottomsheet · high confidence

The example\_nav2 app now includes a complete route configuration in app\_pages.dart and app\_routes.dart, defining a nested navigation structure with distinct pages for home, dashboard, profile, products, settings, and login. The setup demonstrates the use of middlewares (EnsureAuthMiddleware, EnsureNotAuthedMiddleware) for route guards, applies transition effects (size, cupertino), and configures the root navigator participation for specific routes. This provides a concrete example of how to structure complex, nested routes with authentication checks and visual transitions in the GetX navigation system.

_example\nav2/lib/app/routes · high confidence

The example application now includes explicit route definitions for the demo, introducing new pages and bindings for Home, Details, Country, Dashboard, Profile, and Products. This change provides a structured routing setup for the example, allowing users to navigate between these specific views within the GetX framework.

example/lib/routes · high confidence

A new extension on double provides .hp and .wp getters that convert a numeric value into a percentage of the screen's height and width respectively, enabling more intuitive responsive sizing in the UI.

lib/src · high confidence

The library now includes platform-specific implementations for URL strategy: a web implementation using Flutter's PathUrlStrategy, an IO-based stub, and a generic stub. This allows the navigation system to handle URL strategies differently depending on the platform, with the web version removing the hash from URLs.

_lib/get\_navigation/src/routes/url\strategy · high confidence

A new ProductsBinding class is introduced to register the ProductsController as a lazy dependency, enabling the application to load the controller only when needed, which can improve initial load times and reduce memory usage.

_example\nav2/lib/app/modules/products/bindings · high confidence

A new RootController is introduced in the root module, extending GetxController to manage application state and lifecycle. The controller initializes a reactive count property and implements the onInit and onClose lifecycle hooks, providing a foundation for root-level state management and cleanup.

_example\nav2/lib/app/modules/root/controllers · medium confidence

Added a new root view that integrates a side drawer for navigation and a GetRouterOutlet for content, establishing the primary application shell with a RouterListener to update the app bar title based on the current route.

_example\nav2/lib/app/modules/root/views · high confidence

The example application now includes a translation service that supports English (en\_US) and Portuguese (pt\_BR). The service automatically detects the device's system language and falls back to English if the user's preferred language is not available.

example/lib/lang · high confidence

The example\_nav2 directory now includes standard Flutter project configuration files: a .gitignore to exclude build artifacts and IDE files, a .metadata file tracking Flutter version and migration state, a README.md with getting started instructions, and an analysis\_options.yaml file that includes the flutter\_lints package for code quality checks.

_example\nav2 · high confidence

Introduced new \Response\ and \GraphQLResponse\ classes to manage HTTP responses, including a \copyWith\ method for immutable updates and a \status\ property for status code checks. Added \RedirectInfo\ and \HttpHeaders\ interfaces/constants to support redirect tracking and header access.

_lib/get\connect/http/src/response · high confidence

The example application now includes a complete Linux desktop implementation. This adds the necessary CMake build configuration, GTK application entry points, and plugin registration to enable building and running the app on Linux desktop environments.

_example\nav2/android · high confidence

A new controller, ProductDetailsController, has been added to manage the product details module. This controller handles initialization and cleanup logging for a specific product ID, providing a dedicated class to manage the state and lifecycle of the product details view.

_example\_nav2/lib/app/modules/product\details/controllers · high confidence

A new controller class, ProductsController, has been added to the products module. This controller manages a reactive list of DemoProduct objects and provides a method to load demo products. It also includes lifecycle hooks to initialize data on ready and log information on close, supporting the navigation example's product management functionality.

_example\nav2/lib/app/modules/products/controllers · high confidence

Introduced a new ProductsView component within the example\_nav2 module, providing a user interface for displaying a list of products with a floating action button to add items and a refreshable list view.

_example\nav2/lib/app/modules/products/views · high confidence

A new ProfileController class has been introduced in the profile module, extending GetxController to manage profile-related state and logic within the application.

_example\nav2/lib/app/modules/profile/controllers · high confidence

The example application now includes a ProfileView component, allowing users to see how a profile page is structured within the new navigation system. This addition demonstrates the integration of the profile module with the updated routing and dialog handling mechanisms.

_example\nav2/lib/app/modules/profile/views · medium confidence

A new SettingsController has been introduced in the settings module, providing a reactive count state and an increment method to manage settings-related logic.

_example\nav2/lib/app/modules/settings/controllers · high confidence

Added example implementations of authentication middleware in the GetX navigation layer. The new \auth\_middleware.dart\ file provides two concrete examples of route guards: \EnsureAuthMiddleware\ to protect routes requiring login, and \EnsureNotAuthedMiddleware\ to prevent authenticated users from accessing login screens. These serve as templates for implementing route guards using the \redirectDelegate\ method.

_example\nav2/lib/app/middleware · high confidence

A new dashboard module has been introduced, comprising a binding, controller, and view. The dashboard view displays a live-updating clock that refreshes every second, demonstrating the updated navigation and dependency injection patterns in the example app.

_example\nav2/lib/app/modules/dashboard · high confidence

The example directory now includes standard Flutter project configuration files (.gitignore, .metadata, analysis\_options.yaml) and documentation (README.md, example.md) that introduce the GetX framework's state management and navigation features to new users.

example · high confidence

A new HomeController class has been introduced in the home module, extending GetxController to manage the home screen's state and logic using the GetX framework.

_example\nav2/lib/app/modules/home/controllers · high confidence

The iOS project structure for the example\_nav2 application has been added, including the Xcode project file (project.pbxproj), workspace configurations, build phase scripts, and essential iOS configuration files such as Info.plist, AppFrameworkInfo.plist, and the AppDelegate. This establishes the native iOS build environment required to compile and run the Flutter application on iOS devices and simulators.

_example\nav2/ios · high confidence

A new \LoginController\ class has been added to the example application, extending \GetxController\ to manage the login module's state and logic.

_example\nav2/lib/app/modules/login/controllers · high confidence

A new login view component has been added to the example application, demonstrating how to handle authentication state and navigation using GetX. The view displays the current login status and provides a button to trigger the login process, illustrating the integration of the new navigation and routing features in the example project.

_example\nav2/lib/app/modules/login/views · high confidence

A new MockClient class has been introduced in the HTTP library to facilitate testing by allowing developers to provide a custom handler that transforms requests into responses. This enables easier unit testing of components that depend on HTTP connectivity without making real network calls.

_lib/get\connect/http/src/http/mock · medium confidence

The library now supports sending multipart/form-data requests. This is enabled by new \FormData\ and \MultipartFile\ classes that handle the encoding of form fields and file uploads into the correct MIME format, including support for multiple files and list fields.

_lib/get\connect/http/src/multipart · high confidence

A new \GetModifier\ class has been introduced in the HTTP client library to enable request and response modification via interceptors. This allows users to register custom logic that can alter outgoing requests or incoming responses, providing a way to handle authentication, logging, or data transformation at the network layer.

_lib/get\connect/http/src/interceptors · high confidence

The example\_nav2 web application now includes the necessary static assets to run as a Progressive Web App (PWA). An index.html file has been added to serve as the entry point, configuring the base href, meta tags for mobile compatibility, and linking the Flutter bootstrap script. Additionally, a manifest.json file has been introduced to define the app's name, display mode, theme colors, and icon assets, enabling proper installation and display on home screens.

_example\nav2/web · high confidence

A new GetCore module is introduced, consolidating core functionality into a single entry point. This module exports Flutter engine, interface, main, logging, smart management, and type definitions, providing a unified API surface for these components.

_lib/get\core · high confidence

Added a new GetHttpClient class that wraps an underlying IClient implementation, exposing configuration options for timeouts, redirects, user-agent headers, and trusted certificates. The client supports custom request and response interceptors, handles various body types (FormData, Map, List, String, null) with appropriate content-type and content-length headers, and allows for proxy and credential settings. This provides a more flexible and configurable HTTP client for the GetConnect library.

_lib/get\connect/http/src · high confidence

The library now exposes a consolidated entry point at lib/get\_state\_manager/get\_state\_manager.dart, which re-exports the core state management components including RxGetXWidget, RxNotifier, RxObxWidget, RxTicketProviderMixin, GetControllers, GetResponsive, GetState, GetView, and SimpleBuilder. This change provides a unified API surface for accessing GetX's reactive state management features, making it easier for users to import and use these components.

_lib/get\_state\manager · high confidence

A new HomeBinding class has been added to register the HomeController as a lazy singleton within the GetX dependency injection system, enabling the home module to access the controller without immediate instantiation.

_example\nav2/lib/app/modules/home/bindings · high confidence

A new \body\_decoder.dart\ utility was added to \lib/get\_connect/http/src/http/utils\ to handle HTTP response body decoding. This component parses JSON content when the MIME type is 'application/json', falling back to the raw string if decoding fails or if the content is not JSON. It also supports a custom decoder function provided by the request, ensuring that the response body is correctly transformed into the expected type or returned as a string when no decoder is specified.

_lib/get\connect/http/src/http/utils · high confidence

Added a new animation library in the lib/get\_animations directory, featuring a core GetAnimatedBuilder widget and specific animation classes including FadeIn, FadeOut, Rotate, Scale, Bounce, Spin, Size, Blur, and Flip. These are exposed via extension methods on Flutter's Widget class, allowing developers to easily apply these animations to any widget using a fluent API.

_lib/get\animations · high confidence

Added a new GetDialogRoute class that extends Flutter's PopupRoute to handle dialog-style navigation. This change provides a dedicated route implementation for dialogs, including support for barrier dismissal, barrier color, transition duration, and custom transition builders, improving the composability and structure of dialog navigation within the library.

_lib/get\navigation/src/dialog · medium confidence

Added a new \GetObserver\ class that extends \NavigatorObserver\ to monitor Flutter navigation events (push, pop, remove, replace). This observer extracts route names, arguments, and state changes (e.g., bottom sheet, dialog) and updates a \Routing\ data structure, enabling developers to track and react to navigation state changes within the GetX framework.

_lib/get\navigation/src/routes/observers · high confidence

Added a new \RouterReportManager\ class in \lib/get\_navigation/src/router\_report.dart\ to track and manage the lifecycle of route-bound instances. This manager links dependencies to specific routes, allowing for automatic cleanup of \Get.create()\ instances and other non-singleton controllers when a route is disposed. The \ExtensionNavigation\ file was also added to provide context-free navigation methods like \bottomSheet\ and \dialog\, enabling users to show modals and dialogs without needing a BuildContext.

_lib/get\navigation/src · high confidence

A new GetSocket class is added to the library, extending BaseWebSocket and accepting an allowSelfSigned parameter, enabling connections to servers using self-signed certificates.

_lib/get\connect/sockets · high confidence

Added new files home\_api\_provider.dart and home\_repository.dart in the example/lib/pages/home/data directory. The API provider extends GetConnect to fetch country data, while the repository handles error checking and data mapping, implementing the IHomeRepository interface.

example/lib/pages/home/data · medium confidence

Introduced new \GetMaterialApp\ and \GetCupertinoApp\ widgets that serve as the root entry points for navigation and state management. These components consolidate configuration for routing, themes, internationalization, and logging, providing a unified way to initialize the GetX framework in Flutter applications.

_lib/get\navigation/src/root · high confidence

The example application now includes a new shared module containing a centralized API endpoint constant (API\_URL) and a reusable logging mixin (Logger) that prints formatted messages to the console.

example/lib/shared · high confidence

The \lib/get\_rx\ module is reintroduced with a new internal structure, separating the reactive stream implementation (\rx\_stream\), the core Rx types (\rx\_types\), and the worker utilities (\rx\_workers\). This change provides a cleaner, modularized API for reactive variables (like \RxInt\, \RxString\, \RxList\), stream subscriptions, and background workers (like \ever\, \once\, \interval\), making the library easier to maintain and extend.

_lib/get\rx · high confidence

The example application now includes the complete set of native Windows files required to build and run on Windows. This includes the CMake build configuration, the Windows runner code (including the Win32 window management, run loop, and Flutter window integration), and the generated plugin registrant. Users can now build and run the example on Windows.

_example\_nav2/macos, example\nav2/windows · high confidence

The \get\_utils\ library has been restructured into a modular package with a new internal directory structure, exporting components from \src/equality\, \src/extensions\, \src/get\_utils\, \src/platform\, and \src/queue\. This change introduces a dedicated \Equality\ mixin and related classes for object comparison, adds a \GetQueue\ for managing asynchronous job execution, and provides platform detection utilities. The refactoring also includes various utility extensions for strings, numbers, and widgets, alongside fixes for deprecated APIs and linter errors.

_lib/get\utils · high confidence

The example app now includes explicit dependency injection bindings for the Profile and Settings modules. Each module (ProfileBinding and SettingsBinding) registers its respective controller (ProfileController and SettingsController) using lazy initialization, ensuring controllers are instantiated only when first accessed. This change supports a more composable and lazy-loading architecture within the application's navigation and state management.

_example\_nav2/lib/app/modules/profile/bindings, example\nav2/lib/app/modules/settings/bindings · high confidence

A new root binding has been introduced to register the RootController as a lazy dependency, enabling the navigation system to instantiate the controller on first use rather than at startup.

_example\nav2/lib/app/modules/root/bindings · high confidence

A new ProductDetailsView was added to the product details module, displaying a centered column with a status text and the current product ID. This view serves as the visual representation for the product details route, decoupling the logical route from the visual implementation.

_example\_nav2/lib/app/modules/product\details/views · medium confidence

The home view now utilizes GetRouterOutlet for nested routing, allowing the dashboard, profile, and products routes to be managed within a single outlet. A BottomNavigationBar is integrated via IndexedRouteBuilder to switch between these nested routes, providing a structured navigation experience for the home module.

_example\nav2/lib/app/modules/home/views · medium confidence

A new SettingsView widget has been added to the settings module, providing a basic UI that displays 'SettingsView is working' within a centered text element. This change supports the overall navigation system rework by introducing the settings screen as a navigable route.

_example\nav2/lib/app/modules/settings/views · high confidence

The navigation implementation in \lib/get\_navigation/src/routes\ has been completely refactored to support a new routing architecture. This includes the introduction of \GetDelegate\ as the primary router delegate, \GetPageRoute\ for managing page states and transitions, and \GetInformationParser\ for handling route information. The change also introduces \RouteDecoder\ and \RouteTree\ for matching and managing route definitions, alongside new classes like \GetBackGestureDetector\ for handling swipe-back gestures. These components work together to provide a more composable and flexible navigation experience, replacing the previous implementation.

_lib/get\navigation/src/routes · high confidence

The Snackbar implementation has been completely refactored to support a message queue, ensuring snackbars appear sequentially rather than simultaneously. This change introduces new features such as an \onHover\ callback, configurable animation curves, and improved memory management to prevent leaks. The API has been updated to prepare for GetX 5, including the addition of \Get.backLegacy()\ and \Get.closeAllSnackbars()\, while maintaining backward compatibility with Flutter 3.x.

_lib/get\navigation/src/snackbar · high confidence

The example application's main entry point has been replaced with a new implementation that utilizes the GetX navigation 2 API. This change updates the example to demonstrate the modern routing approach, featuring a list of GetPage definitions for first, second, third, and fourth screens, along with corresponding controllers and widgets that showcase navigation and state management within the example/lib directory.

example/lib · high confidence

The library now exposes a set of core abstractions and utilities in lib/get\_core/src, including a Flutter engine wrapper, a GetInterface for merging auxiliary packages, a singleton Get implementation for navigation, and a logging system where logs are enabled by default only in debug mode. It also introduces a SmartManagement enum to control how controllers are disposed, and a ValueUpdater typedef. These changes shift logging behavior and provide new APIs for memory management and logging configuration.

_lib/get\core/src · high confidence

The product details module now uses a new binding that registers the ProductDetailsController using Get's spawn method, which enables lazy loading of the controller. This change decouples the logical route from the visual route, allowing the controller to be instantiated only when needed, which can improve initial load times and reduce memory usage by deferring controller creation until the route is actually visited.

_example\_nav2/lib/app/modules/product\details/bindings · high confidence

A new LoginBinding class is added to the login module, registering the LoginController as a lazy dependency. This change provides a composable API for dependency injection within the login module, replacing the previous disposable interface pattern.

_example\nav2/lib/app/modules/login/bindings · medium confidence

Adds domain models (Country, CountriesItem) and corresponding binding classes (HomeBinding, DetailsBinding) that wire up the home page's data layer. The bindings register lazy dependencies for the home provider, repository, and controllers, enabling the home page to fetch and display country data through a more composable, typed API.

example/lib/pages/home/bindings · high confidence

The HTTP client now exposes a new \Request\ class that encapsulates request properties such as headers, URL, method, and body. A key behavioral change is introduced in the \copyWith\ method: by default, it merges existing headers with new ones (\appendHeader = true\), ensuring that origin headers are preserved during request modification rather than being replaced.

_lib/get\connect/http/src/request · high confidence

The library now exposes a consolidated entry point that exports the core navigation components (including bottom sheets, routes, and observers) alongside the snackbar implementation. This structural change organizes the public API, making it easier to import and use the navigation and snackbar features together.

_lib/get\navigation · high confidence

The example app's home and details views have been completely redesigned to use a modern, gradient-based aesthetic with blurred backdrops, custom cards, and updated button styles. The home screen now features a list of countries with hero images and navigation to a details view that displays country-specific information in a styled card. These changes reflect a significant visual update to the example application's user interface.

example/lib/pages/home/presentation/views · high confidence

The library introduces a new \InstanceInfo\ class to expose instance state and adds \resetInstance\ and \spawn\ methods to the \GetInterface\ for better control over singleton and lazy registrations. A new \GetLifeCycleMixin\ is provided to manage controller lifecycles, while the \Bindings\ system is updated with a \BindingsInterface\ for more composable dependency management.

_lib/get\instance · high confidence

The home and details controllers in the example app have been refactored to extend StateController, enabling automatic state management for their respective data models (List\<CountriesItem\> and Country). The onInit lifecycle methods now utilize the futurize helper to handle asynchronous repository calls, simplifying loading, success, and error state management with minimal code.

example/lib/pages/home/presentation/controllers · high confidence

The library introduces a new, composable reactive widget API for Flutter. The \GetX\ widget now manages controller lifecycle and dependency injection, replacing the previous \GetBuilder\ pattern. A new \Obx\ and \ObxValue\ widgets provide simpler reactive UI updates. Additionally, \StateMixin\ is added to controllers to standardize loading, success, error, and empty states, while \GetTickerProviderStateMixin\ simplifies \AnimationController\ usage in controllers.

_lib/get\_state\_manager/src/rx\flutter · high confidence

The state management core has been refactored to introduce a new, composable controller hierarchy. \GetxController\ is now the base class for stateful controllers, extending \ListNotifier\ and \GetLifeCycleMixin\. New controller types include \StateController\ for managing async loading/error/success states, and \SuperController\ which combines full lifecycle awareness with state management. The widget layer has been restructured: \GetWidget\ now uses a \WidgetCache\ mechanism for instance management, and \GetView\ provides a cleaner way to access controllers. Additionally, a \ScrollMixin\ has been added to support infinite scroll patterns, and \GetResponsiveWidget\/\GetResponsiveView\ provide responsive layout capabilities based on screen size.

_lib/get\_state\manager/src/simple · high confidence

The library's public API has been reorganized into distinct, modular entry points for better clarity and usage. Users can now import specific capabilities directly, including \get.dart\ for the full framework, \get\_connect.dart\ for HTTP requests, \instance\_manager.dart\ for dependency injection, \route\_manager.dart\ for navigation, \state\_manager.dart\ for state management, and \utils.dart\ for utility functions. This change simplifies imports by allowing developers to include only the modules they need rather than the entire framework.

lib · high confidence

The example application now includes a DemoProduct model and an AuthService to support route guard examples. The DemoProduct class provides a simple data structure with name and id fields, while the AuthService implements a mock login/logout mechanism using GetX's reactive state management. These additions enable the route guard example to demonstrate authentication-based navigation control.

_example\_nav2/lib/models, example\nav2/lib/services · medium confidence

Added benchmark tests for state management and stream performance; Added comprehensive navigation tests for dialogs, bottom sheets, snackbars, and route parsing; Added custom test matchers for instance utilities; Added smoke test for Flutter widget; Added test utilities for navigation and internationalization; Added tests for GetInstance lifecycle and replacement; Added tests for Rx reactive utilities and listeners; Added tests for internationalization support; Added unit and widget tests for the example application; Added unit and widget tests for utility extensions; Added unit tests for GetUtils and GetPlatform; Added unit tests for animation extensions and GetAnimatedBuilder; Added widget tests for GetX state management.

The main package (pubspec.yaml) is updated to version 5.0.0-release-candidate-9.3.3, with the SDK constraint raised to \>=3.12.0 and Flutter to \>=3.22.0. The dependency on the 'web' package is explicitly added. Additionally, two new example projects are introduced: 'example' (GetDemo) and 'example\_nav2' (ExampleNav2), which demonstrate usage of the library with updated linting dependencies (flutter\_lints ^5.0.0 and ^6.0.0 respectively).

(dependencies) · high confidence

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

• CAI 62 → 70 (+7.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 95 → 93 (-2.4)
• Architecture 98 → 93 (-5.0)
• Maturity 57 → 57 (-0.1)
• Readiness 50 → 67 (+17.5)
• Security 80 → 100 (+20.3)
• Domain Modelling 100 → 100 (+0.0)

• Change coupling: extension_navigation.dart ↔ router_report.dart (lib/get_navigation/src/extension_navigation.dart)
• Change coupling: get_information_parser.dart ↔ route_middleware.dart (lib/get_navigation/src/routes/get_information_parser.dart)
• Change coupling: get_information_parser.dart ↔ router_outlet.dart (lib/get_navigation/src/routes/get_information_parser.dart)
• Change coupling: get_navigation.dart ↔ parse_route.dart (lib/get_navigation/get_navigation.dart)
• 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)
• No exposed public API
• Test reliability not included
• The README mentions pub.dev but does not link directly to the GetX package page (https://pub.dev/packages/getx). (README.md)
• complexity unreadable for .dart, .swift — churn × complexity hotspots could not be measured

• BindElement.initState (cognitive 18) (lib/get_state_manager/src/simple/get_state.dart)
• ClassTooLong: GetDelegate (lib/get_navigation/src/routes/get_router_delegate.dart)
• ClassTooLong: GetHttpClient (lib/get_connect/http/src/http.dart)
• ConfigData.== (cognitive 41) (lib/get_navigation/src/root/get_root.dart)
• ConfigData.== (cyclomatic 42) (lib/get_navigation/src/root/get_root.dart)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (lib/get_utils/src/get_utils/get_utils.dart)
• Duplicated block (11 lines × 2) (lib/get_navigation/src/routes/observers/route_observer.dart)
• Duplicated block (11 lines × 2) (lib/get_state_manager/src/rx_flutter/rx_getx_widget.dart)
• Duplicated block (11–13 lines × 2) (lib/get_navigation/src/snackbar/snackbar.dart)
• Duplicated block (12 lines × 2) (lib/get_connect/http/src/http.dart)
• Duplicated block (12 lines × 2) (lib/get_navigation/src/routes/default_transitions.dart)
• Duplicated block (12 lines × 2) (lib/get_navigation/src/routes/get_router_delegate.dart)
• Duplicated block (12 lines × 3) (lib/get_navigation/src/routes/default_transitions.dart)
• Duplicated block (12–13 lines × 4) (lib/get_connect/http/src/http.dart)
• Duplicated block (13 lines × 2) (lib/get_navigation/src/routes/default_transitions.dart)
• Duplicated block (14 lines × 2) (lib/get_navigation/src/routes/get_router_delegate.dart)
• Duplicated block (14–19 lines × 2) (lib/get_navigation/src/routes/get_router_delegate.dart)
• …and 38 more

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

jonataslaw/getx 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.