felangel/bloc

This system is a comprehensive state management library and ecosystem for Dart and Flutter applications, centered around the BLoC and Cubit patterns. It provides core packages for managing application state, handling side effects, and persisting data, alongside specialized packages for concurrency, testing, and linting. The repository also includes a wide array of example applications and code generation templates that demonstrate various architectural patterns, including form validation, infinite lists, and authentication flows.

39 changes.

This period focused on modernizing the core BLoC library by removing legacy APIs and introducing new features like MultiBlocObserver. Simultaneously, the project expanded its ecosystem by releasing flutter\_bloc and angular\_bloc, while significantly growing the example repository with diverse Flutter, AngularDart, and VS Code/IntelliJ tooling.

41 changes.

This period focused on standardizing the BLoC/Cubit pattern across all example applications, introducing state management implementations for login, counter, weather, and infinite list scenarios. Significant effort was also dedicated to comprehensive test coverage, adding unit and widget tests for all examples, alongside infrastructure improvements like web support and macOS plugin registration.

38 changes.

This period focused on expanding the BLoC/Cubit ecosystem with new concurrency transformers, CLI tooling, and code-generation bricks supporting multiple styles. It also involved modernizing example applications with comprehensive state management, declarative routing, and full test coverage.

4 changes.

This period focused on expanding the BLoC ecosystem with the introduction of the bloc\_lint package to enforce best practices across the library. Additionally, the project improved web platform support by adding necessary entry points and manifests for various examples, while also establishing a baseline for iOS unit testing.

The hydrated\_bloc package now includes a .gitignore file to exclude build artifacts, IDE settings, and platform-specific files from version control. Additionally, the package now ships with a standard MIT LICENSE file, a comprehensive CHANGELOG.md documenting all versions and changes, a README.md with usage examples and documentation, an analysis\_options.yaml for linting, and benchmarking documentation and charts in the benchmark directory.

_packages/hydrated\bloc · high confidence

A new AngularDart-based GitHub Search example has been added to the repository. This standalone demo application utilizes the AngularDart framework and the angular\_bloc package to implement a search interface for GitHub repositories. The example includes all necessary source files, templates, and configuration to run the application.

_examples/github\_search/angular\_github\search · high confidence

A new example application demonstrating how to use the BLoC pattern with streams is added. The app features a TickerApp that provides a TickerBloc, and a TickerPage that uses BlocBuilder to react to state changes (TickerInitial, TickerTickSuccess, TickerComplete) and allows the user to trigger events via a floating action button.

_examples/flutter\_bloc\_with\stream/lib · high confidence

The project now includes a new 'flutter\_bloc\_feature' brick that generates Flutter BLoC/Cubit architecture templates. This includes view templates for both BLoC and Cubit patterns, providing ready-to-use widget structures that integrate with the flutter\_bloc package. The templates include provider and builder components that scaffold the standard BLoC/Cubit setup for new features.

_bricks/flutter\_bloc\feature/\\brick\\_ · high confidence_

A new Flutter counter example has been added to the repository, demonstrating a state management approach using the \flutter\_bloc\ library. The implementation features a \CounterCubit\ that manages an integer state and exposes \increment\ and \decrement\ methods. The UI is split into a \CounterPage\ that provides the BLoC via \BlocProvider\, and a \CounterView\ that uses \BlocBuilder\ to display the current count and trigger state changes via floating action buttons.

_examples/flutter\counter/lib/counter · high confidence

The \examples/flutter\_todos\ directory now contains a complete Flutter application demonstrating state management with the BLoC pattern. The app includes a home screen with tabs for viewing and editing todos, a stats page, and full internationalization support. It utilizes \RepositoryProvider\ for dependency injection and implements a \BlocObserver\ for logging BLoC state changes. The example is configured with multiple build flavors (development, staging, production) and includes standard project files like \analysis\_options.yaml\ and \.gitignore\. This serves as a reference implementation for using the \flutter\_bloc\ and \hydrated\_bloc\ packages in a real-world scenario.

(repo-wide) · high confidence

Introduced a new Flutter example application named 'flutter\_dynamic\_form' to demonstrate dynamic form handling. The addition includes the full project structure: a .gitignore file for build artifacts and IDE files, a .metadata file for Flutter tooling, a README with getting started instructions, an analysis\_options.yaml file that extends the repository's standard linting rules, and the core Dart source files (new\_car.dart) exporting the new car bloc and view. Additionally, a pubspec\_overrides.yaml file is added to override local package paths for development.

(repo-wide) · medium confidence

A new example demonstrating form validation with the BLoC pattern has been added to the repository. The example implements a login form handling email and password changes, focusing on validation state management using the Formz library. This provides a concrete reference for implementing reactive form validation in Flutter applications.

_examples/flutter\_form\validation/lib/bloc · high confidence

A new example application demonstrating form validation with the BLoC pattern has been added to the examples/flutter\_form\_validation/lib directory. The app implements a login form with email and password fields, utilizing Flutter's FocusNode for focus management and the BLoC pattern for state management. The example showcases how to handle form submission, display validation errors, and manage UI states such as success dialogs and loading indicators.

_examples/flutter\_form\_validation/lib, examples/flutter\_infinite\list/lib/posts/view · high confidence

A new Flutter example demonstrating an infinite scrolling list has been added to the repository. The example includes the application entry point, a custom BLoC observer for logging transitions and errors, and the core application structure using the flutter\_bloc and provider packages.

_examples/angular\_counter, examples/flutter\_infinite\list/lib · high confidence

The flutter\_infinite\_list example was added to the repository, providing a starting point for a Flutter application demonstrating an infinite list. The example includes standard configuration files such as .gitignore and .metadata for Flutter project management. To facilitate local development and testing, pubspec\_overrides.yaml was added to override the bloc, bloc\_test, and flutter\_bloc dependencies with local paths to the corresponding packages in the repository, ensuring the example uses the local versions of these libraries.

_examples/flutter\_infinite\_list, examples/flutter\login · high confidence

A new Flutter example project named 'flutter\_shopping\_cart' has been added to the repository. This includes the standard Flutter project structure with configuration files such as .gitignore, .metadata, README.md, analysis\_options.yaml, and pubspec\_overrides.yaml. The pubspec overrides are configured to use local paths for the bloc, bloc\_test, and flutter\_bloc packages, indicating this is a development example for the BLoC library.

_examples/flutter\_complex\_list, examples/flutter\_form\_validation, examples/flutter\_shopping\cart · high confidence

A new Flutter shopping cart example has been added to the repository, demonstrating a complete BLoC implementation for managing cart state. The example includes a CartBloc that handles cart events (starting, adding items, removing items) and emits corresponding states (loading, loaded, error). The implementation uses the equatable package for value-based equality checks on events and states, and relies on a ShoppingRepository for data operations. This provides a reference implementation for building stateful Flutter applications using the BLoC pattern.

_examples/flutter\_shopping\cart/lib/cart/bloc · high confidence

Users can now generate a Hydrated Bloc implementation via the new 'hydrated\_bloc' brick. The brick provides three distinct code-generation styles—basic, equatable, and freezed—allowing developers to choose the level of boilerplate and serialization support that best fits their project. The brick includes the necessary template files and a pre-generation hook to configure the output based on the selected style.

_bricks/hydrated\bloc/\\brick\\_ · high confidence_

The Flutter Weather example now includes a dedicated \open\_meteo\_api\ package that provides a Dart client for the Open-Meteo weather service. This adds \Location\ and \Weather\ data models with JSON serialization, along with an \OpenMeteoApiClient\ that exposes \locationSearch\ and \getWeather\ methods. The change also introduces corresponding unit tests for the client and models, and configures the package with standard Dart analysis options and build settings.

_examples/flutter\_weather/packages/open\_meteo\api · high confidence

A new example application, flutter\_bloc\_with\_stream, has been added to demonstrate the BLoC pattern with Dart 3 features. The example introduces a TickerBloc that utilizes sealed classes for events and states, implements the Equatable interface for value-based equality, and employs the restartable transformer from bloc\_concurrency to manage stream-based updates.

_examples/flutter\_bloc\_with\stream/lib/bloc · medium confidence

Introduced a new Zed extension that provides snippets and the Bloc language server for Dart and Flutter apps. The extension includes a Rust-based implementation to automatically download and manage the \bloc\_tools\ language server binary, alongside JSON files defining code snippets for BLoC, Cubit, testing, and freezed support.

extensions · high confidence

The Flutter shopping cart example now includes a complete implementation of the catalog feature using the BLoC pattern. This adds a new \CatalogBloc\ that manages the loading, success, and error states for the product catalog, along with corresponding \CatalogEvent\ and \CatalogState\ classes. The example also introduces data models for \Catalog\ and \Item\, utilizing the \equatable\ package for value equality. This change provides a concrete, testable example of how to structure a Flutter app using the \bloc\ library.

_examples/flutter\_shopping\cart/lib/catalog/bloc · high confidence

The flutter\_form\_validation example now includes new model classes for email and password validation, implemented via the Formz library. These models provide structured validation logic for email addresses and passwords, enhancing the example's demonstration of form validation capabilities.

_examples/flutter\_form\validation/lib/models · high confidence

The Flutter todos example now includes a new \local\_storage\_todos\_api\ package that implements the \TodosApi\ interface using \SharedPreferences\ for persistent storage. This adds support for saving, retrieving, and managing todo items locally on the device, with corresponding unit tests verifying the behavior of save, delete, and completion operations.

_examples/flutter\_todos/packages/local\_storage\_todos\api · high confidence

The flutter\_login example now includes a complete BLoC implementation for the login screen, introducing login\_bloc.dart, login\_event.dart, and login\_state.dart. This adds the business logic for handling username and password changes, form validation using Formz, and submission states, providing a concrete example of how to structure authentication flows with the BLoC pattern.

_examples/flutter\_login/lib/login/bloc, examples/flutter\_login/packages/authentication\repository · medium confidence

The Flutter shopping cart example now supports macOS as a desktop platform. This is enabled by adding the necessary macOS project configuration, including a .gitignore file for Flutter and Xcode build artifacts, and a GeneratedPluginRegistrant.swift file to handle plugin registration on the macOS platform.

_examples/flutter\_shopping\_cart/macos, examples/flutter\timer/macos · high confidence

A new 'New Car' form page has been introduced, allowing users to select a car brand, model, and year via dropdown menus. The form integrates with the application's state management (BLoC) to handle selections and displays a confirmation message upon submission.

_examples/flutter\_dynamic\_form/lib/new\car/view · high confidence

The Flutter Firebase Login example now includes a complete sign-up flow. A new sign-up form (sign\_up\_form.dart) provides email, password, and confirm-password inputs with real-time validation and error handling via the BLoC pattern. The corresponding page (sign\_up\_page.dart) wraps the form in a Scaffold with an AppBar and provides routing. The view layer is exported via view.dart. This adds the ability for users to create a new account through the example app.

_examples/flutter\_firebase\_login/lib/sign\up/view · high confidence

The todos\_repository package has been added to the Flutter todos example, providing a repository layer that wraps the todos\_api client. The package includes a TodosRepository class that exposes methods for getting, saving, deleting, and completing todos, as well as a dispose method to close the underlying API client. A corresponding unit test file has been added to verify the repository's behavior using mock objects.

_examples/flutter\_todos/packages/todos\repository · high confidence

The flutter\_login example now includes a dedicated user\_repository package, introducing a User model and a UserRepository class that simulates fetching a user with a 300ms delay. This change provides a structured way to manage user state within the login example, leveraging the equatable and uuid packages for model equality and ID generation.

_examples/flutter\_login/packages/user\repository/lib · high confidence

The Flutter shopping cart example now includes the necessary web-specific files (index.html and manifest.json) to support running the application in a browser. This enables users to access the shopping cart functionality via a web interface, in addition to any existing mobile or desktop targets.

(repo-wide) · medium confidence

The flutter\_firebase\_login example was added, providing a complete reference implementation for Firebase authentication using the bloc state management library. The example includes a local in-memory CacheClient for storing user sessions, integrates with Firebase for sign-in/sign-up flows, and is configured with the bloc\_lint package for consistent code analysis. This addition allows users to see how to structure a Flutter app with separate authentication and cache packages, alongside updated iOS workspace configurations.

_examples/flutter\_firebase\login · high confidence

The dynamic form example now includes a complete BLoC implementation for the 'new car' feature, introducing \new\_car\_bloc.dart\, \new\_car\_event.dart\, and \new\_car\_state.dart\. This adds the business logic for managing car selection states (brands, models, years) and handles the corresponding events and state transitions within the Flutter application.

_examples/flutter\_dynamic\_form/lib/new\car/bloc · high confidence

The cart view now includes a new CartPage that displays the list of items in the user's cart, showing each item's name and a long-press action to remove that item. The page also displays the cart's total price and a 'BUY' button that currently shows a 'not supported yet' message. This introduces the ability to remove individual items from the cart via long-press interaction.

_examples/flutter\_shopping\cart/lib/cart/view · high confidence

The Flutter Weather example now includes a GeneratedPluginRegistrant.swift file for macOS, which registers the PathProvider plugin. This enables the example to properly initialize and use the path\_provider plugin on macOS, ensuring consistent plugin registration across platforms.

_examples/flutter\weather/macos/Flutter · high confidence

The Flutter login example now includes a dedicated splash screen. A new \SplashPage\ widget has been added to display a loading indicator during the initial load, with the route and view logic separated into distinct files within the \splash\ directory.

_examples/flutter\login/lib/splash · high confidence

The example now includes the standard web scaffolding required to run the Flutter application in a browser. This adds the \index.html\ entry point, which configures the base href and loads the Flutter bootstrap script, alongside a \manifest.json\ file that defines the app's metadata, including icons, theme colors, and display settings for mobile and desktop browsers.

_examples/flutter\_complex\_list/web, examples/flutter\_dynamic\_form/web, examples/flutter\_form\validation/web · high confidence

The flutter\_bloc\_with\_stream example now includes the standard web entry point (index.html) and the web app manifest (manifest.json). These files configure the HTML shell, meta tags, icons, and PWA settings required for the Flutter web build to run in a browser.

_examples/flutter\_bloc\_with\stream/web · high confidence

The bloc package has been updated to version 9.2.1, introducing the MultiBlocObserver class which allows registering multiple BlocObserver instances to observe all bloc lifecycle events. Additionally, the library now supports an onDone callback in the BlocObserver to handle completion or cancellation of event handlers, providing better visibility into the lifecycle of bloc operations.

packages/bloc · high confidence

The Flutter Login example now supports running in a web browser. This is enabled by adding the standard web entry point (index.html) and the web app manifest (manifest.json), which configure the app's title, icons, and manifest properties for the web platform.

_examples/flutter\login/web · high confidence

The flutter\_bloc package is now available, providing Flutter widgets (BlocBuilder, BlocListener, BlocProvider, BlocConsumer, BlocSelector) that integrate with the bloc state management library. This release includes the core widgets for state management, dependency injection via BlocProvider, and a complete example application demonstrating usage patterns.

_packages/flutter\bloc · high confidence

The flutter\_counter example is initialized with standard Flutter project files, including .gitignore, .metadata, README.md, and analysis\_options.yaml. Additionally, a pubspec\_overrides.yaml is added to override the bloc, bloc\_test, and flutter\_bloc packages with local paths, ensuring the example uses the local development versions of these packages.

_examples/flutter\counter · high confidence

The flutter\_bloc\_with\_stream example is introduced with standard Flutter project scaffolding, including .gitignore, .metadata, README, analysis\_options, and pubspec\_overrides. The pubspec\_overrides.yaml configures local path dependencies for the bloc, bloc\_concurrency, bloc\_test, and flutter\_bloc packages, enabling the example to reference the local monorepo packages directly.

_examples/flutter\_bloc\_with\stream · high confidence

The IntelliJ plugin now supports generating BLoC, Cubit, and Equatable props via new action classes (GenerateBlocAction, GenerateCubitAction, GenerateEquatablePropsAction) and associated dialog and generator components. Additionally, the plugin introduces intention actions for wrapping widgets with BLoC-related widgets (BlocBuilder, BlocListener, etc.) and converting to multi-widget providers (MultiBlocProvider, MultiRepositoryProvider).

_extensions/intellij/intellij\_generator\plugin · high confidence

The \angular\_bloc\ package is added, providing a \BlocPipe\ that binds \Bloc\ and \Cubit\ state changes to the AngularDart presentation layer. This new package includes the core pipe implementation, unit tests, and example code, enabling developers to easily implement the BLoC pattern in AngularDart applications.

_packages/angular\bloc · high confidence

The Flutter Firebase Login example now includes a new AppBlocObserver that implements the BlocObserver interface to log BLoC events, errors, changes, and transitions via print statements. This provides a centralized mechanism for debugging and monitoring the state of BLoC instances throughout the application.

_examples/flutter\_firebase\login/lib/app · high confidence

Added the core BLoC implementation for the Flutter login example, including the AuthenticationBloc class and its associated events and states. The bloc manages authentication status and user data, utilizing the bloc library's onEach pattern to react to repository status changes and handle logout events.

_examples/flutter\login/lib/authentication/bloc · high confidence

Added the \ComplexListCubit\ class and its corresponding \ComplexListState\ enum and class in the \examples/flutter\_complex\_list/lib/complex\_list/cubit\ directory. The cubit manages the state of a complex list, handling loading, success, and failure states, and provides methods to fetch and delete items from a repository, updating the UI state accordingly.

_examples/flutter\_complex\_list/lib/complex\list/cubit · high confidence

Added the \flutter\_bloc\_feature\ brick, which generates BLoC and Cubit templates for Flutter applications. The brick includes pre-generation hooks that automatically run \dart format\ and \dart fix --apply\ to ensure generated code adheres to style guidelines and best practices. The implementation supports multiple BLoC types (bloc, cubit, hydrated variants, and replay variants) and manages their respective dependency versions.

_bricks/flutter\_bloc\feature/hooks · medium confidence

Users can now generate a HydratedCubit using the Mason CLI, choosing from three output styles: basic, equatable, or freezed. The brick provides corresponding state templates for each style, allowing developers to select the level of boilerplate and equality handling that fits their project.

_bricks/hydrated\cubit · high confidence

The \bloc\_lint\ package is introduced as the official linting solution for the Bloc library ecosystem. It provides a suite of lint rules to enforce best practices, including \avoid\_flutter\_imports\, \avoid\_public\_bloc\_methods\, \avoid\_public\_fields\, \prefer\_bloc\, \prefer\_cubit\, \prefer\_file\_naming\_conventions\, \prefer\_void\_public\_cubit\_methods\, \avoid\_build\_context\_extensions\, and \prefer\_build\_context\_extensions\. The package supports \analysis\_options.yaml\ configuration with \include\ and \exclude\ paths, allows ignoring specific rules via \// ignore\ and \// ignore\_for\_file\ comments, and integrates with the Dart analyzer frontend to report diagnostics for BLoC and Cubit instances.

_packages/bloc\lint · high confidence

The new bloc\_tools package provides a command-line interface for the Bloc state management library. Users can now run \bloc lint\ to analyze Dart source code for quality and consistency, and \bloc new\ to scaffold new Bloc, Cubit, HydratedBloc, and related components from templates. A hidden \language-server\ command is also included to support IDE integrations. The tool supports disabling automatic update checks via the \BLOC\_UPDATE\_CHECK=false\ environment variable.

_packages/bloc\tools · high confidence

The Flutter complex list example now includes a dedicated data model for list items, featuring an immutable Item class with id, value, and isDeleting fields, along with a copyWith method and equality support. This model is exposed via a new models barrel file and re-exported through the main complex\_list.dart entry point, providing a clean API for the example's state management.

_examples/flutter\_complex\_list/lib/complex\_list, examples/flutter\_complex\_list/lib/complex\list/models · high confidence

Added a new Flutter example demonstrating a complex list with state management via BLoC/Cubit. The implementation includes a page widget that provides the Cubit and a list view that handles loading, success, and failure states, along with an item tile that supports deletion actions.

_examples/flutter\_complex\_list/lib/complex\list/view · high confidence

The \replay\_bloc\ package is introduced, providing \ReplayCubit\ and \ReplayBloc\ classes that extend the standard \Cubit\ and \Bloc\ types to support automatic undo and redo operations. This new feature allows users to navigate through state history using \undo()\, \redo()\, and \clearHistory()\ methods, with optional history limits and filtering via \shouldReplay\. The package includes a full example application demonstrating usage with Flutter, along with comprehensive test coverage for both the BLoC and Cubit implementations.

_packages/replay\bloc · high confidence

The \common\_github\_search\ package is introduced to centralize GitHub search functionality, providing a \GithubRepository\ that handles API calls via \GithubClient\ and caching through \GithubCache\. The package exposes a \GithubSearchBloc\ for state management, along with supporting models like \SearchResult\ and \GithubUser\. Additionally, a standardized \analysis\_options.yaml\ is added to enforce linting rules via \bloc\_lint\.

_examples/github\_search/common\_github\search · high confidence

The authentication repository now provides specific exception classes for sign-up, login, and Google sign-in failures, mapping Firebase error codes to user-friendly messages. This allows the application to catch and display meaningful error messages to users during authentication processes.

_examples/flutter\_firebase\_login/packages/authentication\repository/lib/src · high confidence

Users can now generate a new ReplayBloc in Dart using the new replay\_bloc brick. The tool scaffolds the necessary files (bloc, event, and state classes) and supports three generation styles: basic, equatable, and freezed, allowing developers to choose the level of boilerplate and equality handling that fits their project.

_bricks/replay\_bloc, bricks/replay\cubit · high confidence

Added the todos\_api package to the Flutter todos example, introducing a new Todo model class with JSON serialization and a TodosApi interface defining methods for retrieving, saving, deleting, and managing todos. The package also includes corresponding unit tests for the Todo model and the TodosApi interface.

_examples/flutter\_todos/packages/todos\api · high confidence

Added the complete source code for the Flutter Weather example, including the main entry point, the \WeatherCubit\ for state management, and UI components for displaying, searching, and configuring weather data. The example also includes a \WeatherRepository\ package that fetches data from the Open-Meteo API, along with corresponding unit tests for the repository and model serialization.

_examples/flutter\weather · high confidence

The example application now includes a dedicated Post model class that extends Equatable to provide value-based equality and a props list for serialization or comparison. This model is exported via a new models.dart barrel file, making the Post class available for use in the infinite list example.

_examples/flutter\_infinite\list/lib/posts/models · high confidence

A new Flutter login example has been added, providing a complete login page and form implementation using the BLoC pattern. The example demonstrates state management via BlocListener and context.select for reactive UI updates, integrating with an AuthenticationRepository for login flow handling.

_examples/flutter\login/lib/login/view · high confidence

Added a new example in the Flutter BLoC with Stream guide that demonstrates how to use Stream APIs inside a BLoC. The new \ticker.dart\ file introduces a \Ticker\ class that emits integer values periodically using Dart's \Stream.periodic\ method, providing a concrete pattern for handling periodic data streams within the BLoC architecture.

_examples/flutter\_bloc\_with\stream/lib/ticker · high confidence

The bloc\_concurrency package is introduced, providing four custom event transformers for the Bloc library: concurrent, sequential, droppable, and restartable. These allow developers to control how events are processed—simultaneously, in order, by ignoring new events during processing, or by cancelling previous handlers for the latest event. The package includes full documentation, an example, and comprehensive tests for each transformer.

_packages/bloc\concurrency · high confidence

The Flutter shopping cart example now includes a new catalog page that displays a list of items using a sliver-based layout. This change introduces the CatalogPage widget, which renders a scrollable list of items with loading, error, and loaded states, alongside supporting components like AddButton, CatalogAppBar, and CatalogListItem that handle item display and cart interactions.

_examples/flutter\_shopping\cart/lib/catalog/view · medium confidence

The VS Code extension now includes new commands and code actions to generate Bloc and Cubit templates, supporting Freezed, Equatable, and simple class styles. Users can now create new Blocs and Cubits via the command palette, with options for sealed classes and template types. Additionally, the extension provides code actions to convert existing code to MultiBlocProvider, MultiBlocListener, and MultiRepositoryProvider, as well as wrap selected code with BlocBuilder, BlocSelector, BlocListener, BlocConsumer, BlocProvider, and RepositoryProvider. The extension also integrates with the Bloc language server for analysis and provides dependency version checking to prompt users to update outdated packages.

extensions/vscode · high confidence

The form\_inputs package now exports three new form input classes—Email, Password, and ConfirmedPassword—each extending FormzInput to provide built-in validation. Email inputs are validated against a standard email pattern, password inputs require at least one letter, one digit, and a minimum length of eight characters, and confirmed password inputs verify that the entered value matches a provided password string. These components are now available for use in the Flutter Firebase login example.

_examples/flutter\_firebase\_login/packages/form\inputs/lib · high confidence

The home screen now displays the user's avatar, email, and name, and includes a logout button in the app bar. The implementation introduces a new HomePage widget that uses the AppBloc to select the current user state and renders an Avatar widget for the user's photo, with a fallback icon if no photo is available. The logout functionality is wired via context.read\<AppBloc\>().add(const AppLogoutPressed()).

_examples/flutter\_firebase\login/lib/home · high confidence

The shell script responsible for running Flutter package installation, Dart formatting, and static analysis has been removed from the repository.

scripts · high confidence

A new HomePage widget is introduced in the flutter\_login example, displaying the current user's ID and a logout button. The page uses context.select to subscribe to the AuthenticationBloc's state for the user ID, and context.read to trigger the logout action, demonstrating the updated BLoC usage pattern in the example.

_examples/flutter\login/lib/home/view · high confidence

New barrel files (cart.dart and catalog.dart) have been added to the Flutter shopping cart example. These files re-export the public API for the cart and catalog modules, simplifying imports for consumers of these modules.

_examples/flutter\_shopping\_cart/lib/cart, examples/flutter\_shopping\cart/lib/catalog · high confidence

The sign-up flow now requires users to confirm their password before submitting the form. The SignUpCubit and SignUpState have been updated to track and validate a confirmed password field, ensuring both password fields match before allowing the sign-up request to proceed.

_examples/flutter\_firebase\_login/lib/sign\up/cubit · high confidence

The Cubit code-generation brick has been updated to version 0.3.0, introducing new generation styles for state management. Users can now generate Cubits using the \equatable\ or \freezed\ packages in addition to the existing \basic\ style. This allows for automatic equality checking with Equatable or immutable state classes with Freezed. The brick also updates its dependencies to use Mason ^0.1.0 and Dart ^3.5.4.

bricks/cubit · high confidence

The login form validation logic has been refactored into dedicated model classes. The \Password\ and \Username\ classes now extend \FormzInput\ to handle empty-state validation, exposing error states via \PasswordValidationError\ and \UsernameValidationError\ enums respectively. This change improves code organization within the \flutter\_login\ example by separating model logic from the main login widget.

_examples/flutter\login/lib/login/models · high confidence

The Flutter infinite list example now uses extracted, reusable widget components: a dedicated BottomLoader for the loading indicator and a PostListItem for individual post entries. These changes improve code organization and reusability within the example application.

_examples/flutter\_infinite\list/lib/posts/widgets · high confidence

The Flutter GitHub Search example now uses the new \dispose\ callback on \RepositoryProvider\ to properly clean up the \GithubRepository\ instance, ensuring resources are released when the widget tree is disposed.

_examples/github\_search/flutter\_github\search · high confidence

The Flutter Firebase login example now includes an \App\ widget that sets up the application's dependency injection and state management. Specifically, it provides the \AuthenticationRepository\ and initializes the \AppBloc\ with lazy=false, ensuring the bloc is created immediately. The \AppView\ widget uses a \FlowBuilder\ to manage navigation based on the \AppStatus\ from the bloc, wrapping the app in a \MaterialApp\ with a custom theme.

_examples/flutter\_firebase\login/lib/app/view · medium confidence

The Flutter Firebase Login example now includes a new AppBloc implementation that manages application state using the bloc pattern. The AppBloc reacts to user subscription requests and logout events, updating the AppState with the current user status (authenticated or unauthenticated). This change introduces a more reactive approach to handling user authentication state, leveraging the bloc library's capabilities for state management.

_examples/flutter\_firebase\login/lib/app/bloc · high confidence

The authentication repository now exposes a structured User model to represent user data. This model includes fields for the user's ID, email, name, and photo URL, and provides a static empty instance to represent an unauthenticated state. This change replaces the previous approach of using a simple string (or 'anonymous user') to track authentication status, offering a more robust and typed representation of user information within the Flutter Firebase login example.

_examples/flutter\_firebase\_login/packages/authentication\repository/lib/src/models · high confidence

The Flutter Firebase Login example now uses a declarative route generation approach via the new \routes.dart\ file. This change replaces the previous routing mechanism with a \onGenerateAppViewPages\ function that maps the application's authentication state (\AppStatus\) to specific pages (\HomePage\ or \LoginPage\), providing a more explicit and state-driven navigation flow for the login example.

_examples/flutter\_firebase\login/lib/app/routes · high confidence

The Flutter Firebase Login example has been updated to use the latest \flutter\_bloc\ and \hydrated\_bloc\ libraries, reflecting a shift to a more modern state management approach. The application entry point (\main.dart\) now initializes the Flutter binding, configures a custom \BlocObserver\, and sets up Firebase, while the login feature is structured around a \login\_cubit\ and associated view. Additionally, the app's visual presentation has been enhanced with a new \theme.dart\ file that applies Google Fonts and a cohesive color scheme, improving the overall user experience of the example.

_examples/flutter\_firebase\login/lib · medium confidence

The login example has been updated to use the \flutter\_bloc\ library for state management, introducing a \LoginCubit\ that handles email and password validation, login progress, and authentication failures. The \LoginForm\ widget now displays error messages via \ScaffoldMessenger\ when authentication fails, and uses \context.select\ to efficiently subscribe to specific state changes. The UI includes dedicated widgets for email, password, login, Google sign-in, and sign-up, with proper error states and loading indicators.

_examples/flutter\_firebase\login/lib/login/view · high confidence

The login screen now uses a LoginCubit and LoginState to manage form state and submission. This introduces explicit handling for login failures, displaying error messages via the errorMessage field in the state, which addresses previous issues with repeated error snackbars.

_examples/flutter\_firebase\login/lib/login/cubit · medium confidence

The PostBloc implementation was refactored to use a throttle-based event transformer (throttleDroppable) instead of previous debouncing or unthrottled handling, ensuring that rapid user interactions are rate-limited to improve performance. The state management was also simplified by introducing a dedicated PostState class with a status enum and a hasReachedMax flag, which allows the UI to correctly hide the bottom loader when no more posts are available.

_examples/flutter\_infinite\list/lib/posts/bloc · high confidence

The legacy abstract Bloc class has been removed from the library. This base class previously managed event-to-state mapping via a PublishSubject and switchMap, requiring subclasses to implement mapEventToState. Its removal indicates a shift away from this specific implementation pattern in favor of newer APIs.

lib/src · high confidence

The top-level re-export file lib/bloc.dart has been removed. Users who previously imported the library via lib/bloc.dart will need to update their imports to reference the source file directly (e.g., lib/src/bloc.dart or the appropriate public API path).

lib · high confidence

The iOS build configuration for the Flutter Firebase Login example has been updated to a new Xcode scheme file (Runner.xcscheme). This change aligns the example with modern Xcode project structures, ensuring that build, test, launch, and archive actions are correctly configured for the Runner target.

_examples/flutter\_firebase\login/ios/Runner.xcodeproj/xcshareddata · medium confidence

The Android build configuration for the Flutter Firebase Login example has been updated to use Gradle 8.12. This change ensures the project uses a specific, modern version of the Gradle wrapper, which may bring performance improvements and compatibility updates for the Android platform code.

_examples/flutter\_firebase\login/android/gradle · high confidence

The Android configuration for the Flutter Firebase Login example has been updated to support the V2 Android embedding, which is required for Flutter 2.10 and later. This includes adding the \flutterEmbedding\ meta-data to the \AndroidManifest.xml\ and updating the \MainActivity\ to extend \FlutterActivity\. Additionally, the example now includes a debug \AndroidManifest.xml\ to grant internet permissions for hot reload and debugging, and provides standard launch splash screen resources.

_examples/flutter\_firebase\login/android/app/src · medium confidence

The BLoC brick templates have been updated to provide three distinct implementation styles for generated code: basic (standard Dart classes), equatable (using the equatable package for value equality), and freezed (using the freezed package for immutable state and sealed classes). The pre-generation hook now selects the appropriate template based on the chosen style, ensuring the generated bloc, event, and state files match the selected pattern.

bricks/bloc/\\brick\\_ · high confidence_

The iOS configuration for the Flutter Firebase Login example has been updated to support the modern embedding API. This includes adding a new \AppDelegate.swift\ that registers plugins via the modern \GeneratedPluginRegistrant\, updating \Info.plist\ with the correct bundle identifiers and URL schemes for Google services, and adding necessary asset catalogs for app icons and launch screens. These changes ensure the example app builds and runs correctly on iOS with the latest Flutter tooling.

_examples/flutter\_firebase\login/ios/Runner · high confidence

The Flutter Firebase Login example now includes updated iOS build configuration files (AppFrameworkInfo.plist, Debug.xcconfig, and Release.xcconfig) to support the modern Flutter embedding API. This ensures the example builds correctly with current Flutter tooling and resolves deprecation warnings related to the older embedding API.

_examples/flutter\_firebase\login/ios/Flutter · medium confidence

The iOS project file for the Flutter Firebase Login example has been updated to reflect the latest Flutter and Firebase integration standards. This includes the addition of test targets and framework references, ensuring the example app builds and runs correctly with modern iOS tooling.

_examples/flutter\_firebase\login/ios/Runner.xcodeproj · medium confidence

The \bloc\_test\ package has been updated to version 10.0.0, introducing a breaking change where \blocTest\ now depends on core interfaces instead of \BlocBase\. This refactor aligns the testing library with the internal architecture of the \bloc\ package. The package also upgrades its dependency on \bloc\ to version 9.0.0, and enforces a minimum Dart SDK of 2.14.

_packages/bloc\test · high confidence

Add unit tests for the Settings page; Added Flutter counter example integration test driver; Added comprehensive test coverage for the Flutter shopping cart example; Added comprehensive tests for the Flutter Dynamic Form example; Added iOS unit test scaffold for the Runner app; Added integration tests for the Flutter counter example; Added route generation tests for the Flutter Firebase login example; Added test helper for HydratedBloc storage mocking; Added tests for AppBlocObserver; Added tests for the CacheClient; Added unit and widget tests for the Flutter timer example; Added unit and widget tests for the catalog feature; Added unit and widget tests for the login form and page; Added unit tests for AppBloc and AppState; Added unit tests for Flutter Login example BLoC and models; Added unit tests for the Avatar widget; Added unit tests for the Cart BLoC; Added unit tests for the CartPage, CartList, and CartTotal widgets; Added unit tests for the Flutter Login example's authentication logic; Added unit tests for the Ticker BLoC and its events/states; Added unit tests for the User model; Added unit tests for the WeatherCubit and WeatherState; Added unit tests for the login cubit and state; Added unit tests for the sign-up form and page components; Added widget tests for the AppView component; Added widget tests for the Flutter Weather example app; Added widget tests for the Flutter login example; Added widget tests for the HomePage component; Added widget tests for the TickerPage and app entry point; Added widget tests for the WeatherPage; Added widget tests for weather UI states.

All example applications and internal tooling (bricks, docs) have been upgraded to require Dart SDK ^3.10.0, with many examples targeting ^3.12.0. This includes updating \pubspec.yaml\ files across the repository to use the latest versions of \bloc\, \flutter\_bloc\, \hydrated\_bloc\, and other core packages, ensuring compatibility with modern Dart and Flutter versions.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 49.

• Code Health 93
• Architecture 89
• Maturity 65
• Readiness 44
• Security 47
• Domain Modelling 100
• Accessibility 42

• 300 commits — 274 feature/other, 26 fixes

• docs/src — 46 commits
• docs/package-lock.json — 40 commits
• extensions/vscode — 40 commits
• packages/bloc_lint — 38 commits
• packages/bloc_tools — 23 commits
• extensions/intellij — 22 commits
• examples/flutter_todos — 12 commits
• packages/bloc — 11 commits
• packages/hydrated_bloc — 10 commits
• .github/workflows — 9 commits
• .github/actions — 8 commits
• (root) — 3 commits
• examples/bloc_concurrency_visualizer — 3 commits
• examples/flutter_weather — 3 commits
• examples/github_search — 3 commits
• extensions/zed — 3 commits
• packages/bloc_concurrency — 3 commits
• packages/bloc_test — 3 commits
• packages/flutter_bloc — 3 commits
• examples/flutter_firebase_login — 2 commits

• fix: chore(angular_github_search): pin build_web_compilers to fix builds (#4833)
• fix: chore(vscode): npm audit fix (#4595)
• fix: chore(vscode): npm audit fix (#4692)
• fix: chore: fix angular dart builds (#4832)
• fix: fix(bloc): isClosed should incorporate event controller state (#4809)
• fix: fix(bloc_lint): analysis_options.yaml resolution in pub workspace (#4734)
• fix: fix(bloc_lint): avoid_public_bloc_methods false positive (#4521)
• fix: fix(bloc_lint): prefer_void_public_cubit_methods false positive (#4525)
• fix: fix(bloc_lint): ignore .fvm (#4542)
• fix: fix(bloc_lint): include bloc/cubit instances declared in any file (#4569)
• fix: fix(bloc_test)!: propagate lifecycle events to registered BlocObserver (#4688)
• fix: fix(bloc_tools): bloc lint canonicalize path (#4498)
• fix: fix(bloc_tools): add override for pkg:test v1.27.0 regression (#4677)
• fix: fix(bloc_tools): bump pkg:bloc_lint to ^0.3.3 (#4650)
• fix: fix(docs): remove stray backtick in RepositoryProvider docs (#4555)
• fix: fix(hydrated_bloc)!: HydratedCubit storage override should be a named parameter (#4537)
• fix: fix(hydrated_bloc): make defaultOnHydrationError public
• fix: fix(hydrated_bloc): serialize non-string keys (#4758)
• fix: fix(intellij): apache commons text missing on some IJ versions (#4480)
• fix: fix(intellij): include environment during command execution (#4503)
• …and 280 more

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

felangel/bloc 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.