wednesday-solutions/flutter_template

This is a Flutter-based weather application that allows users to search for cities, view current conditions, and manage a list of favorite locations. It employs a clean architecture with distinct domain, interactor, and presentation layers, utilizing Riverpod for state management and AutoRoute for navigation. The system supports multiple build flavors (dev, QA, production) and features dynamic theming, local database caching via Drift, and bilingual support for English and Hindi.

86 changes.

The codebase underwent a comprehensive architectural overhaul, migrating from GetX to a clean architecture with Riverpod, AutoRoute, and GetIt. This period introduced robust support for multiple environments, responsive UI layouts, and dynamic theming, while adding significant new features like city search, favorites, and localized content.

5 changes.

This period focused on establishing consistent UI typography and robust error handling through a new text theme and a sealed Result type. Development also introduced a reusable template for screen destinations and expanded end-to-end test coverage using the Patrol framework.

The app now supports English (US) and Hindi (India) translations. New translation keys and localized strings for the home page, search page, forecast, and theme settings have been added, enabling users to switch between English and Hindi in the application.

lib/presentation/intl · high confidence

A new logging utility is introduced in lib/foundation/logger/logger.dart, providing a singleton Logger instance via the LogHelper class. This implementation wraps the 'logger' package and includes a custom filter that restricts log output to debug mode and respects a 'showLogs' configuration flag, ensuring that detailed logs are only active during development.

lib/foundation/logger · high confidence

New domain-layer use cases have been introduced to handle date-to-milliseconds conversion and date formatting. The \DateInMillisUseCase\ and its implementation delegate to the \DateRepository\ to convert \Date\ objects to integer milliseconds, while \FormatDateUseCase\ and its implementation use the repository to format dates into strings, enabling the UI to display and process date data consistently.

lib/domain/datetime · medium confidence

Users can now toggle dynamic theming and select a preferred theme mode (Light, Dark, or System) via a new theme picker widget. The change introduces a DynamicThemeSwitch widget that binds to the theme view model, allowing users to enable or disable dynamic theming. Additionally, a ThemePicker widget provides a popup menu to choose between different theme modes, integrating the dynamic theme toggle as the first option in the selection list.

lib/presentation/base/widgets/theme · high confidence

The home page now includes a language toggle button in the app bar, allowing users to switch between English and Hindi. Additionally, a search icon in the app bar navigates users to the search screen. The home screen also displays a list of favorite cities' weather conditions.

lib/presentation/destinations/weather/home · high confidence

Introduced new presentation-layer data classes (UICity, UIDayWeatherHeading, UIWeather) that implement the UIListItem interface, enabling the UI to consume structured weather and city data for display.

lib/presentation/entity/weather · high confidence

Introduced a responsive layout system that adapts the application to mobile, tablet, and desktop screen sizes. This includes a \ResponsiveBreakpoints\ configuration class, a \ScreenType\ enum with logic to detect the current device type based on screen width, and base UI components such as \UIListItem\ and \UIToolbar\ to support the new presentation layer.

lib/presentation/entity/base · high confidence

A new responsive layout system has been introduced to the presentation layer, providing two new Flutter widgets: ResponsiveBuilder and ResponsiveScreenTypeBuilder. ResponsiveBuilder wraps content with LayoutBuilder and MediaQuery to expose screen constraints and dimensions to child builders. ResponsiveScreenTypeBuilder uses these to determine the current device type (mobile, tablet, desktop) based on configurable breakpoints and orientation, allowing developers to render different UIs for each screen type. This enables the application to adapt its layout to different screen sizes and orientations.

lib/presentation/base/widgets/responsive · high confidence

A new \ScaffoldBodyWithLoadingIndicator\ widget is introduced in the presentation layer, providing a reusable scaffold body that automatically displays a loading indicator (defaulting to a \CircularProgressIndicator\) when the associated view model's state indicates loading. The widget integrates with the Riverpod state management system to watch the \showLoading\ property of the view model's state, allowing UI to reflect loading states without manual state checks in each screen.

lib/presentation/base/widgets/scaffold · high confidence

A new \SearchPageLoadingShimmer\ widget has been added to the weather search UI. This component renders a three-item shimmer loading animation using the project's theme colors, providing a visual placeholder while search results are being fetched.

_lib/presentation/destinations/weather/search/widgets/search\_page\_loading\shimmer · high confidence

A new theme repository has been introduced to manage the application's theme mode (light, dark, or system) and the dynamic theme setting. The implementation persists these preferences using the existing preferences repository, allowing the UI to adapt to user-selected themes and dynamic theming options.

lib/repository/theme · medium confidence

The weather home screen now renders a list of weather conditions and headings using new UI components. A heading item displays a text title with a fixed font size, while the main weather list item displays the title, current temperature, an icon image, feels-like temperature, min/max temperatures, and a description, all styled using the app's theme. Each widget is paired with a corresponding renderer that implements the list item renderer interface to integrate with the home screen's intent handling.

lib/presentation/destinations/weather/home/widgets/list · high confidence

Introduced a new weather search feature, including the SearchPage route, SearchScreen definition, and associated intent, state, and view-model implementations. The search page displays a list of search results and supports searching by city, with a 400ms debounce on the search input. Users can also toggle cities as favorites or navigate back from the search screen.

lib/presentation/destinations/weather/search · high confidence

A new Effect entity has been introduced in the presentation layer to handle UI-specific actions. This includes a SnackBarEffect for displaying temporary messages with configurable duration, behavior, and dismissal options, as well as a HideKeyboardEffect for managing keyboard visibility.

lib/presentation/entity/effect · high confidence

A new JSON converter class has been introduced to handle date-time serialization, providing static methods to parse ISO 8601 date strings into Dart DateTime objects and serialize DateTime objects back to ISO 8601 strings.

lib/services/base/json · high confidence

Introduced new UI components for the weather search feature: a city list item widget that displays city names and handles favorite toggling via intents, and a corresponding renderer that implements the list item rendering interface to instantiate these widgets.

lib/presentation/destinations/weather/search/widgets/list · high confidence

Introduced new entity classes to support the OpenWeather API, including remote DTOs for current weather conditions (temperature, humidity, wind, clouds, etc.) and location data, along with corresponding local database tables for caching.

lib/services/entity · high confidence

A new Mason brick named 'destination' has been added to the bricks directory, providing a template for generating new screen destinations. This includes the full set of generated files: a page widget, screen class, state, view model, and intent classes, along with a post-generation hook that runs the Flutter build runner. The template uses Dart sealed classes for intents and Freezed for state management, integrating with the existing base classes and providers.

bricks · high confidence

New shell scripts have been added to the \scripts\ directory to automate common development tasks and CI/CD workflows. These include \build.sh\ and \run.sh\ for managing Flutter builds and runs across different environments (dev, qa, prod), \bump-build-number.sh\ and \commit-version.sh\ for automated versioning, and \generate-all.sh\ for code generation. The \setup-hooks.sh\ script configures local git hooks, while \install\_certs.sh\ handles certificate installation for iOS builds. A \README.md\ has been added to document these scripts.

scripts · high confidence

The application now includes domain-layer use cases for managing theme settings. Specifically, it introduces \GetIsDynamicThemeEnabled\ and \SetIsDynamicThemeEnabled\ to control whether the system's dynamic color/theme is enabled, and \GetThemeModeUseCase\ and \SetThemeModeUseCase\ to retrieve and update the application's theme mode. These use cases act as the domain logic layer, delegating to the \ThemeRepository\ to persist and query theme preferences.

lib/domain/theme · high confidence

Added .env, .env.dev, .env.qa, and .env.test files to support environment-specific configuration for the app's flavors. Updated .gitignore to exclude generated files and include run configurations, and added a LICENSE file. Configured build.yaml to specify code generation scopes for drift\_dev, json\_serializable, and freezed. Updated analysis\_options.yaml to exclude additional generated and translation files from linting. Added dart\_test.yaml for golden test tags, mason configuration files, and a sonar-project.properties for code quality analysis.

(repo-wide) · high confidence

Introduced new weather service layers to handle data retrieval and storage. The local layer adds a \WeatherLocalService\ interface and a \WeatherLocalServiceImpl\ backed by the Drift database, alongside a \FakeWeatherLocalService\ for testing. The remote layer adds a \WeatherRemoteService\ interface and \WeatherRemoteServiceImpl\ that fetches current weather and geocoding data from the OpenWeather API using Dio.

lib/services/weather/local · high confidence

The app now supports dynamic theme switching. A new theme management layer has been introduced, including a ThemeState to hold the current theme mode and dynamic setting, a ThemeViewModel to handle state changes, and corresponding intents (SetThemeModeThemeIntent, SetIsDynamicThemeIntent) to trigger updates. This enables users to change the app's appearance dynamically.

lib/presentation/base/theme · high confidence

Users can now have their app theme (light, dark, or system) and dynamic theming settings managed through a new ThemeInteractor. This change introduces the interactor interface and its implementation, which coordinates with domain use cases to get and set the current theme mode and dynamic theme preference. A new ThemeModeMapper handles the conversion between Flutter's ThemeMode and the app's internal AppThemeMode, ensuring the UI receives the correct theme state.

lib/interactor/theme · high confidence

New use cases have been added to the weather domain to support managing favorite cities. This includes fetching and streaming favorite cities and their weather data, as well as adding or removing cities from the favorites list. These changes enable the application to retrieve and update the user's list of favorite cities and their associated weather information.

lib/domain/weather · high confidence

Added web/sql-wasm.js, a modularized build of the SQLite WASM library, and updated web/index.html to load it. This provides the underlying database engine for web-based applications, allowing users to perform SQL operations in the browser.

web · high confidence

Added a new BasePage widget in lib/presentation/base/page/base\_page.dart that provides a standardized layout for pages, including a default AppBar with back button and title, a body area with loading state support, and integration with the ViewModelProvider. The widget also implements a re-render key based on the current locale, ensuring that pages are fully re-rendered when the application language changes.

lib/presentation/base/page · high confidence

Added a new PreferencesRepository interface and its implementation to manage local key-value storage. The repository provides methods to get and save boolean, integer, and string preferences, delegating to the underlying preferences service and including debug logging for each operation.

lib/repository/preferences · high confidence

Added new files in lib/presentation/base/view\_model\_provider that establish a foundational layer for view models and their providers. The base\_view\_model.dart file introduces a BaseViewModel class that extends StateNotifier, providing a standardized way to manage screen state, handle effects via a stream, and manage stream subscriptions with automatic disposal. The view\_model\_provider.dart file adds a ViewModelProvider InheritedWidget that wraps a Riverpod provider, enabling context-based access to view models. Additionally, view\_model\_provider\_ext.dart provides extension methods on BuildContext to simplify accessing the provider and retrieving the view model instance. This change establishes the core architecture for managing view model state and provider access across the application.

_lib/presentation/base/view\_model\provider · medium confidence

A new abstract interface class ListItemRenderer is added to the presentation layer, defining a contract for rendering list items. This interface specifies a getWidget method that accepts a BuildContext, UIListItem data, and a StreamSink for intents, establishing a standardized way to render list items within the application's UI.

lib/presentation/base/renderer · high confidence

Added the SearchCityInteractor and its implementation to handle city search logic, including a stream that combines favorite cities with search results. Introduced the CitySearchResultMapper and UICityMapper to convert domain City entities into UI-friendly UIListItem and UICity objects, enabling the presentation layer to display search results with favorite status.

lib/interactor/weather/search · high confidence

Added a new date and time repository layer that provides methods to retrieve the current date, time, and full datetime, as well as formatting and millisecond conversion. The implementation includes mappers to convert between internal Dart DateTime and domain-specific Date, Time, and DateTime entities, enabling consistent date/time handling across the application.

lib/repository/date · high confidence

Added the FavoriteWeatherInteractor interface and its implementation, which manages favorite city operations such as adding, removing, and fetching favorite cities and their weather data. The new UIWeatherListMapper converts domain weather entities into UI list items, sorting them by title and formatting temperature data. This enables the application to retrieve and display favorite weather information through a dedicated interactor layer.

lib/interactor/weather/favorite · high confidence

A new generic UIList widget has been added to the presentation layer, enabling the rendering of lists with support for multiple item types via a renderers map. The widget manages an intent stream, allowing child items to emit intents through a shared StreamController, which are then forwarded to a provided intentHandler callback. It supports both single-column ListView and multi-column AlignedGridView layouts based on the numberOfColumns configuration.

lib/presentation/base/widgets/list · high confidence

The foundation layer now provides three new abstract interface classes—Mapper, Mapper2, and Mapper3—that define contracts for mapping one, two, or three source types to a target type. Each interface includes a map method tailored to its specific arity, with Mapper also providing a default mapList helper. These interfaces standardize how data transformation logic is structured across the application.

lib/foundation/mapper · medium confidence

The application now stores weather data locally using the Drift database. This change adds the core database configuration (AppDatabase), defines tables for local weather and location data, and sets up the necessary migration and helper utilities to support offline access to weather information.

lib/services/base/database · high confidence

A new preferences service has been added to the application, providing a typed interface (PreferencesService) and an implementation backed by shared\_preferences. This allows the app to store and retrieve boolean, integer, and string values persistently.

lib/services/preferences · high confidence

Users can now search for cities and view favorite city weather conditions. This change adds the \WeatherRepository\ interface and its implementation, which coordinates remote and local data sources. It includes mappers to convert remote API responses and local database records into domain entities (\City\, \Weather\), enabling features like city search, favoriting, and retrieving weather updates for saved locations.

lib/repository/weather · high confidence

Added new domain entity classes to the application's core layer. This includes data models for weather forecasts (City, DayWeather, Weather), base datetime types (Date, DateTime, Time), and configuration enums for app theme modes and preference keys. These entities provide the structured data types used by the domain layer to represent weather conditions, time values, and user settings.

lib/domain/entity · high confidence

Two new Flutter widgets, AppBarBackButton and AppBarTitle, have been added to the base presentation layer. AppBarBackButton conditionally renders a back navigation button based on the screen's toolbar configuration, while AppBarTitle displays the localized title from the screen's state. These components provide a standardized way to render app bar elements using the new state management approach.

lib/presentation/base/widgets/appbar · high confidence

Added new extension methods to simplify common operations: a localization helper on BuildContext for translation keys, a boolean parser for environment variables, logging shortcuts for objects, a blank-check for strings, and a theme accessor on BuildContext.

lib/foundation/extensions · high confidence

A new dependency injection module has been added to register interactor implementations for weather and theme features. This includes the SearchCityInteractor for city search, the FavoriteWeatherInteractor for managing favorite cities, and the ThemeInteractor for handling theme mode and dynamic theme settings, along with their associated mappers.

lib/interactor/di · high confidence

The search page now uses new widget components to handle the search input and display results. The \SearchPageBody\ manages the text input and forwards search terms to the view model, while \SearchPageResults\ and \SearchPageResultsContent\ display the list of search results, handling loading states, empty states, and responsive grid layouts for city items.

_lib/presentation/destinations/weather/search/widgets/search\_page\body · medium confidence

The weather home page now renders a responsive list of favorite cities. When no cities are saved, a localized message is displayed; otherwise, a UI list shows each city using a dedicated renderer. The layout adapts to screen orientation, showing two columns in landscape mode and one in portrait.

_lib/presentation/destinations/weather/home/widgets/home\_page\body · high confidence

The database connection logic has been split into platform-specific implementations. Mobile devices now initialize the SQLite database from a pre-populated asset file, while web platforms use a WebDatabase initialized with the same asset. Unsupported platforms throw an UnsupportedError. This change enables the application to function correctly across mobile and web environments by providing the appropriate database connection strategy for each platform.

lib/services/base/database/connection · high confidence

The RemoteCity model class and its associated serialization files have been removed from the weather service models. This eliminates the unused data structure that previously handled remote city data, simplifying the model layer.

lib/services/model · high confidence

A new text theme has been introduced to define typography styles for the application's user interface. This change adds a \TextTheme\ configuration that sets font sizes, weights, and colors for various text styles (such as display, headline, title, body, and label), ensuring consistent visual presentation across the app.

lib/presentation/base/theme/type · high confidence

The application now supports Hindi (hi-IN) in addition to English (en-US), with new translation files providing localized strings for the home page, search, forecast, and dynamic theme features. The English translation file includes keys for dynamic theming, and the Hindi translation file provides the corresponding Hindi text for these same features.

assets · medium confidence

The Android app now displays a native splash screen while the Flutter UI initializes, replacing the previous launch theme. This is achieved by adding the INTERNET permission, updating the Gradle build to version 8.6, and configuring a new 'Theme.App.Starting' that uses the new ic\_flutter\_template\_github vector drawable as the animated splash icon. The old 'LaunchTheme' styles and meta-data have been removed in favor of the modern SplashScreen API.

android · high confidence

The app startup process has been significantly restructured. Initialization now loads environment-specific configuration files (e.g., .env.dev, .env.qa) and registers shared preferences for storage. All major application modules—services, repositories, domain logic, interactors, presentation, and navigation—are now explicitly wired together using the GetIt dependency injection container. Additionally, the app now supports high refresh rates on Android devices and includes Google Fonts license handling.

lib · high confidence

The presentation layer now uses a centralized dependency injection module to register ViewModels for the home, search, and theme switching features. This replaces the previous approach of using GetX controllers with a state-based approach, providing a more consistent and testable architecture for managing UI state across the application.

lib/presentation/di · high confidence

A new pre-commit hook has been added to the scripts/hooks directory. This hook runs 'flutter analyze' to check for static analysis issues. If the analysis fails, the hook automatically applies Dart fixes and formats the 'lib' directory before failing the commit, ensuring code quality standards are met before changes are committed.

scripts/hooks · high confidence

The application's flavor system has been updated to support dynamic configuration via environment variables. The Flavor enum was changed from PascalCase (DEV, QA, PROD) to lowercase (dev, qa, prod) and now includes a fromString factory method. FlavorConfig now accepts a string identifier to initialize, and FlavorValues has been expanded to include new properties such as openWeatherApiKey, useFakeData, showLogs, useGoogleFonts, and renderFontsInTest, all of which are now loaded from environment variables using the flutter\_dotenv package.

lib/flavors · medium confidence

A new base class, BaseIntent, has been added to the presentation layer. It extends Equatable, ensuring that intent instances can be compared for equality, which is essential for state management and UI updates in the application.

lib/presentation/entity/intent · high confidence

The application now supports dynamic light and dark themes using Material 3. This change introduces a new theme data structure that applies a consistent color scheme across the app, including custom card, snackbar, and app bar styling. The theme system also integrates Google Fonts as an optional enhancement, allowing the UI to adapt to user preferences or system settings for a more modern and cohesive visual experience.

_lib/presentation/base/theme/theme\data · high confidence

Added a new presentation layer for screens, introducing a base \Screen\ interface and a \ScreenState\ abstract class that defines common UI properties like the toolbar and loading state.

lib/presentation/entity/screen · medium confidence

Added new base classes for use cases in the domain layer, including BaseUseCase, BaseAsyncUseCase, BaseStreamUseCase, and BaseUnsafeUseCase, along with an UnknownObjectThrownException. These provide a consistent, safe execution wrapper that logs parameters, catches errors, and returns a Result type, ensuring that all use cases follow a uniform pattern for handling success and failure states.

lib/domain/base · medium confidence

A new navigation module has been added to register navigation-related services with the GetIt dependency injection container. This includes the AppRouter, BaseNavigator, HomeNavigator, and SearchNavigator, replacing the previous GetX-based navigation setup with a cleaner, interface-based architecture.

lib/navigation/di · medium confidence

The dependency injection module for weather services now supports a fake data mode. When the application is configured to use fake data, the system injects fake implementations for both the remote and local weather services, allowing for development and testing without relying on external APIs or local storage.

lib/services/di · high confidence

A new dependency injection module has been added to register repository implementations for weather, theme, and preferences, along with their associated mappers and date utilities. This establishes the data layer's structure for these features, allowing the application to resolve repository instances via the service locator.

lib/repository/di · high confidence

A new sealed class hierarchy for handling results has been added to the core library. The \Result\<T\>\ class now uses Dart's sealed class feature to enforce exhaustive handling of \Success\ and \Error\ states via the \when\ method. Additionally, the \Success\ and \Error\ classes extend \Equatable\, enabling value-based equality checks for these result types.

lib/core · medium confidence

The weather module now uses explicit navigation contracts: HomeNavigator and SearchNavigator define the navigation capabilities for their respective screens. Implementations (HomeNavigatorImpl, SearchNavigatorImpl) wrap the shared BaseNavigator to provide specific actions like navigating to the search screen or going back, decoupling the UI components from the underlying routing mechanism.

lib/navigation/weather · high confidence

The application shell now uses Material 3 with support for dynamic color schemes (light and dark) and theme switching. The app integrates Riverpod for state management and uses the dynamic\_color package to apply system-generated color palettes. Additionally, the app now supports localization via easy\_localization and includes a global snackbar mechanism for displaying user feedback.

lib/presentation · high confidence

The presentation layer now includes two new exception classes to handle specific error conditions more precisely. A \RendererNotRegisteredForTypeException\ is introduced to signal when a renderer is not registered for a given type, while an \UnhandledEffectException\ is added to handle cases where an effect is not handled. These changes improve error handling by providing specific exception types for these scenarios.

lib/presentation/base/exceptions · medium confidence

The Dio HTTP client provider has been moved to a new directory (lib/services/base/di/) and updated to accept a list of custom interceptors, enabling integration with new API key handling. Additionally, the provider now conditionally adds the logging interceptor based on the FlavorConfig setting, allowing users to disable verbose logging in production or specific flavors.

lib/services/base/di · medium confidence

The presentation layer's intent handling has been refactored to use Dart's \abstract interface class\ for the \IntentHandler\ and a function typedef for \IntentHandlerCallback\. This change replaces previous abstract class or freezed-based implementations with stricter interface definitions, ensuring that intent handlers adhere to a specific contract for processing \BaseIntent\ types.

lib/presentation/base/intent · medium confidence

The remote weather service interface (WeatherRemoteService) and its implementation (WeatherRemoteServiceImpl) have been removed from the codebase. This eliminates the ability to search for cities via the remote API, as the associated service files and their dependencies (such as the RemoteCity model) are no longer present.

lib/services/weather · high confidence

The separate entrypoint files for development, production, and QA environments (main\_dev.dart, main\_prod.dart, main\_qa.dart) have been removed. These files previously initialized the application with specific flavor configurations and API base URLs. This change consolidates or removes the previous multi-flavor startup logic, meaning the app no longer uses these distinct entrypoints to configure environment-specific settings at launch.

lib/entrypoints · high confidence

The application's navigation system has been migrated from GetX to the AutoRoute package. This change introduces a new routing configuration in \app\_router.dart\ that defines routes for the Home and Search screens using AutoRoute's declarative API. A \BaseNavigator\ interface and its \BaseNavigatorImpl\ implementation have been added to abstract navigation actions (pushing and popping routes) via the AutoRouter instance. This shift requires the project to use AutoRoute for all future navigation, replacing the previous GetX-based routing logic.

lib/navigation/base · high confidence

The iOS app's main storyboard has been updated to reflect the default canvas size for modern iPhone models (393x852 points) and upgraded to Xcode 21 tooling standards. This ensures the app's initial view controller renders correctly on current devices and aligns with the latest Interface Builder specifications.

ios/Runner/Base.lproj · medium confidence

The application's domain layer now registers all use cases for weather (including favorites and search), theme management, and date formatting through the GetIt dependency injection container. This ensures that all domain interactions are properly wired up, enabling the UI to interact with the domain layer via injected use cases rather than direct instantiation.

lib/domain/di · high confidence

The iOS app's Info.plist has been updated to support dynamic app naming via the $(app\_display\_name) build variable, enabling easier localization and flavor-based naming. Localizations for English (en) have been explicitly declared, and modern iOS keys (CADisableMinimumFrameDurationOnPhone, UIApplicationSupportsIndirectInputEvents) have been added to ensure compatibility with recent iOS versions.

ios/Runner · medium confidence

The iOS build configuration has been restructured to support distinct development, QA, and production environments. New xcconfig files (Debug/Release for dev, prod, and qa) now define specific bundle suffixes and display names for each flavor, replacing the previous single Debug/Release configs. Additionally, the app's CFBundleIdentifier in AppFrameworkInfo.plist was changed from io.flutter.flutter.app to com.wednesday.flutterTemplate, and the Xcode workspace was updated to include the Pods project.

ios/Flutter · medium confidence

The iOS project configuration has been updated to support multiple build environments (dev, qa, prod) with specific debug and release configurations for each. Additionally, the project now includes a new 'RunnerUITests' target and associated framework references, enabling UI testing capabilities for the iOS application.

ios/Runner.xcodeproj · medium confidence

The iOS Xcode project has been updated to support multiple build environments. New Xcode schemes have been added for 'dev' and 'prod' environments, each configured with specific build settings and test targets. The existing default scheme has been renamed to 'qa' and updated to use environment-specific build configurations (e.g., Debug-qa, Profile-prod), enabling developers to easily switch between different app configurations for development, quality assurance, and production builds.

ios/Runner.xcodeproj/xcshareddata · medium confidence

Add end-to-end integration tests for favorites and language switching; Add test helpers and golden test utilities for the presentation layer; Added Android instrumentation test for MainActivity; Added Flutter test configuration for golden tests; Added golden tests for the weather search page; Added mock for SearchViewModel in tests; Added mock implementations for testing; Added test fixtures for weather and city models; Added test helper extensions for mocking and stream assertions; Added unit tests for the weather search view model; Added unit tests for weather domain use cases; Added unit tests for weather repository and city mapper; Added widget tests for the search page; Added widget tests for the weather search page components; Removed obsolete Flutter widget test.

The project has been upgraded to Flutter 3, updating the Dart SDK requirement to \>=3.0.6. Android build configuration has been modernized by migrating to the new Gradle plugin management syntax, introducing product flavors (dev, qa, prod), and updating the Android Gradle plugin to 8.3.0. Additionally, the pubspec has been updated with new dependencies including auto\_route, flutter\_riverpod, and patrol, while removing older packages like getx and freezed.

(dependencies) · medium confidence

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

• CAI 52 → 65 (+12.7)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 100 (-0.2)
• Architecture 98 → 91 (-7.0)
• Maturity 44 → 58 (+13.9)
• Readiness 53 → 64 (+11.3)
• Security 42 → 60 (+18.7)
• Domain Modelling 100 → 100 (+0.0)

• Boundary-crossing change coupling: routes.dart ↔ search_page.dart (lib/navigation/base/routes.dart)
• Boundary-crossing change coupling: routes.dart ↔ template_app.dart (lib/navigation/base/routes.dart)
• Change coupling: base_page.dart ↔ template_app.dart (lib/presentation/base/page/base_page.dart)
• Change coupling: search_page.dart ↔ ui_city_renderer.dart (lib/presentation/destinations/weather/search/search_page.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)
• 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 21 more

• Change coupling: base_page.dart ↔ search_view_model.dart (lib/presentation/base/page/base_page.dart)
• Change coupling: home_page.dart ↔ search_page.dart (lib/presentation/destinations/weather/home/home_page.dart)
• Change-coupling hub: template_app.dart → base_page.dart, home_page.dart, search_view_model.dart (lib/presentation/template_app.dart)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (lib/repository/weather/domain_city_mapper.dart)
• Duplicated block (7 lines × 2) (lib/services/weather/local/fake_weather_local_service.dart)
• 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 37 more

• Containers 0 added · 0 removed · contexts 1 added · 1 removed · edges 0 added · 0 removed

• app

• .

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

wednesday-solutions/flutter_template 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.