Onix-Systems/onix-flutter-project-generator

This system is a comprehensive Flutter project generator that scaffolds and configures mobile and desktop applications. It automates the creation of complex project structures, including state management, routing, and data layers, while integrating with external design and API sources like Figma and Swagger. The tool also manages build pipelines, security configurations, and documentation generation to streamline the initial setup of production-ready Flutter projects.

84 changes.

This period focused on a comprehensive redesign of the project generator, introducing a new 'Basic' architecture with MVVM and Signals-based state management. The application's interface was completely rebuilt with a multi-step wizard flow, replacing legacy screens with modern BLoC-managed screens for project configuration, platform selection, and style management. Additionally, the codebase was modernized with centralized dependency injection, modular logging, and enhanced macOS support.

71 changes.

This period focused on expanding code generation capabilities by integrating Swagger and Figma data sources, enabling the application to parse API specifications and design files into domain entities. The work also introduced comprehensive support for multiple state management architectures and automated build configurations via Fastlane and Makefile generation.

14 changes.

This period focused on implementing comprehensive dialogs for managing data components, requests, and parameters, alongside a new JSON-to-class generation feature. The work also introduced an edit project screen with tabbed navigation and a central configuration service to manage project state.

The SigningGenerator service now creates an Android keystore and updates the project's Gradle build files to configure release signing. It generates a signing properties file, runs the keytool command to create the keystore, and modifies the build.gradle/build.gradle.kts files to apply the signing configuration, supporting both separate and integrated generation modes.

_lib/domain/service/file\_generator\_service/signing\generator · high confidence

A new use case, ClearScreensUseCase, has been added to the domain layer. This component provides a mechanism to clear all screen data by invoking the empty() method on the ScreenRepository, ensuring that screen state is properly reset.

lib/domain/usecase/screen · high confidence

A new domain parameter class, CreateAccountParams, has been added to the project template. This class, generated via the freezed package, encapsulates the email and password fields required for account creation.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/domain/params · high confidence

A new EditProjectScreen has been introduced, providing a tabbed interface for managing project configuration. The screen features two tabs: one for Screens and another for Data Components. It includes navigation buttons to proceed to the generation screen or return to the procedure selection screen, with the continue button's active state tied to project modification status.

_lib/presentation/screen/edit\_project\screen · high confidence

Added data models for Figma node types including connector, document, frame, section, shape with text, sticky, table cell, text, and vector nodes, along with supporting property models for color, paint, node style, and type style. These models enable the application to parse and serialize Figma API responses, allowing users to access structured data about design elements such as fills, styles, and text properties.

lib/data/model/figma · high confidence

Introduced the FigmaNodesMapper and PropertyMapper classes in lib/data/mapper/figma to convert Figma API data models into domain entities. The FigmaNodesMapper handles the mapping of various node types (such as text, frame, section, vector, and connector nodes) to their corresponding entity representations, while the PropertyMapper handles the conversion of paint, node style, and type style properties. This change enables the application to properly interpret and utilize Figma design data within the domain layer.

lib/data/mapper/figma · high confidence

Added domain entity models for various Figma node types, including BaseNode, ConnectorNode, DocumentNode, FrameNode, SectionNode, ShapeWithTextNode, StickyNode, and TableCellNode. Each model is implemented using the Freezed package for immutable data classes with copy and equality support, mapping the structure of Figma's API responses to the application's domain layer.

lib/domain/entity/figma · high confidence

The Figma styles screen now includes dedicated widgets to display color and text styles. A new \StylesWidget\ organizes styles into sections for 'Color styles' and 'Text styles', each sorted alphabetically. Valid styles are displayed in a wrap layout for colors and a list for text styles. Invalid styles are separately grouped under 'Invalid color styles' and 'Invalid text styles' sections, highlighted with an alarm color border. New \ColorStyleItem\ and \TextStyleItem\ widgets render individual style items with appropriate styling and formatting.

_lib/presentation/screen/figma\_styles\screen/widgets · high confidence

Added new files for Firebase authentication: an abstract \FirebaseAuthSource\ interface, a \FirebaseAuthSourceImpl\ that wraps the Firebase Auth SDK to handle sign-in, user creation, logout, and session state, and a constants file defining Firebase error codes. This introduces the foundational remote data source for user authentication in the generated project.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/data/source/remote/firebase · high confidence

A new FirebaseSessionService class has been added to the project template. This service manages the user's authentication status by listening to the FirebaseAuthRepository and exposing the current session status (open or closed) to the rest of the application.

_bricks/flutter\_clean\base/\\brick\\_/{{project\_name.snakeCase()}}/lib/app/service/firebase\_session\service · high confidence

A new PlatformsScreen has been introduced to allow users to select project platforms. This screen displays a list of available platforms and provides navigation controls to proceed to the project settings or return to the project name screen.

_lib/presentation/screen/platforms\screen · high confidence

A new dialog has been introduced to allow users to add, edit, and delete request parameters (including multipart, path, and query types). The interface provides a preview of the configured parameters and enables inline editing or removal of individual entries, with validation to prevent duplicate parameter names.

_lib/presentation/screen/data\_components\_screen\_v2/widget/dialogs/add\_request\_params\dialog · high confidence

A new Screen entity has been introduced in the domain layer, representing a screen with properties for its name, existence, and initial state. The entity includes a state management variant, allowing for different state management strategies. It supports copying, equality checks, and JSON serialization/deserialization.

lib/domain/entity/screen · high confidence

A new sonar-project.properties file is added to the Flutter project template, configuring SonarQube analysis. It sets the project key, enables waiting for the quality gate, excludes generated and platform-specific files, defines source and test directories, and configures the Dart analyzer mode to use Flutter-specific analysis.

_bricks/flutter\_clean\base/\\brick\\_/{{project\_name.snakeCase()}}/{{\#use\sonar}}sonar-project.properties{{ · high confidence

Introduced the \ComponentDialogCubit\ and its associated state models (\ComponentDialogState\) to manage the lifecycle of adding and editing data object components. The new logic handles initializing component lists, adding and editing variables (including duplicate name validation), and constructing \DataObjectComponent\ or \EnumParamComponent\ instances for submission. This provides the underlying state management for the component creation and editing dialogs.

_lib/presentation/screen/data\_components\_screen\_v2/widget/dialogs/add\_edit\_component\dialog/bloc · high confidence

The data components screen now includes dedicated UI widgets to display request and response parameters. New components have been added to the \input\_params\ directory: \FormData\, \InputBody\, \PathParams\, \QueryParams\, and \RequestBody\ for input, along with \ResponseBody\ for output. These widgets render the respective parameters with their types and names, and \InputBody\ and \ResponseBody\ support interactive dialogs to view object details.

_lib/presentation/screen/data\_components\_screen\_v2/widget/input\params · high confidence

The project now includes new local data source implementations for managing user preferences and secure storage. A \PreferencesSource\ interface and its \PreferencesSourceImpl\ are added to handle caching timestamps via shared preferences. Additionally, a \SecureStorageSource\ interface and its \SecureStorageSourceImpl\ are introduced to manage sensitive data (such as access and refresh tokens) using the \flutter\_secure\_storage\ package, with error handling for read, write, and delete operations.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/data/source/local · high confidence

The project name screen now includes a dedicated BLoC that manages user input for the project name, organization, and branch selection. It validates the project name against existing directories and a custom validator, updates the central ConfigService with user changes, and emits state reflecting the validity of the inputs. This enables the UI to reactively display validation status and persist configuration changes.

_lib/presentation/screen/project\_name\screen/bloc · high confidence

The project template now includes new files in the core data layer to handle remote data interactions. This includes a \DioServerErrorMapper\ that translates API responses into specific failure types (\ApiFailure\, \ApiUnknownFailure\) based on \DefaultApiError\ and \ValidatorApiError\ models. Additionally, a \GraphQlConst\ class is added to store the GraphQL base URL configuration.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/core/arch/data · medium confidence

The add request dialog now includes dedicated UI components for managing request parameters and paths. A new AddComponentRow widget provides a searchable dropdown for selecting or creating components, while OperationIdField and PathField handle text input with specific formatters. The PathField also displays unused path parameters as a warning. Additionally, a ParamButton widget supports editing and deleting parameters, and the component selection dropdown now supports searching.

_lib/presentation/screen/data\_components\_screen\_v2/widget/dialogs/add\_request\dialog/widgets · high confidence

The AddRequestParamsDialogCubit and its associated state models have been introduced to manage the lifecycle of request parameters. This includes adding, editing, and deleting parameters for multipart, path, and query types, with built-in validation to prevent duplicate parameter names.

_lib/presentation/screen/data\_components\_screen\_v2/widget/dialogs/add\_request\_params\dialog/bloc · high confidence

The screen generation service now supports generating screens for multiple state management architectures. New generators have been added for BLoC, Cubit, MVVM, Provider, Riverpod (stateful and stateless), and Signals (passive and reactive), alongside existing support for standard stateful and stateless screens. Each generator creates the corresponding screen, routing, and state management files (e.g., BLoC, ViewModel, Provider, or Riverpod files) based on the selected architecture.

_lib/domain/service/file\_generator\_service/screen\generators · high confidence

The splash screen now automatically checks for the latest release version by fetching data from the GitHub API. If a newer version is available, the app will display an update dialog with a link to the latest release; otherwise, it proceeds to the main application. This introduces new BLoC files that handle the version comparison logic and state management for the splash screen.

_lib/presentation/screen/splash\screen/bloc · high confidence

A new splash screen has been added to the application. It displays the app logo with an opacity animation, shows the current local version alongside the remote version, and prompts the user to open the latest release if a new version is available.

_lib/presentation/screen/splash\screen · high confidence

The style generator now supports generating and parsing both color and text style definitions. A new ColorsGenerator and ColorsParser handle reading existing color definitions from the project, preserving them while adding new ones. Similarly, a TextStylesParser and ThemeTextStylesGenerator handle text styles, supporting both default and tailor-specific parsing. The StylesGenerator orchestrates these components, ensuring that existing styles are preserved and new ones are generated appropriately.

_lib/domain/service/file\_generator\_service/style\generator · high confidence

Introduced a new SummaryScreen that displays a comprehensive review of the user's project configuration before generation. The screen presents key project settings including the project path, name, organization, brick source, selected platforms, and various feature toggles such as Firebase Auth, GraphQL, Sentry integration, and state management preferences. It also lists generated screens and Swagger URLs, providing a final checkpoint for users to verify their selections.

_lib/presentation/screen/summary\screen · high confidence

Two new widgets, SummaryCell and SummaryStylesCell, have been added to the summary screen. SummaryCell renders a simple key-value pair, while SummaryStylesCell displays a list of color and text style objects, including color swatches and detailed typography information.

_lib/presentation/screen/summary\screen/widgets · medium confidence

A new AddEditRequestDialog widget has been introduced to allow users to create or modify request components within the data components screen. The dialog includes fields for path, operation ID, and request type, along with support for managing body components and handling Swagger parser failures. This provides a centralized interface for editing request configurations.

_lib/presentation/screen/data\_components\_screen\_v2/widget/dialogs/add\_request\dialog · high confidence

A new AddRequestDialogCubit and its associated state models have been introduced to the data components screen's add request dialog. This implementation handles the logic for creating and editing source requests, including managing request bodies, responses, and parameters (multipart, path, and query). The component validates parameter names for duplicates and coordinates with use cases to add or edit source requests and their associated components.

_lib/presentation/screen/data\_components\_screen\_v2/widget/dialogs/add\_request\dialog/bloc · high confidence

A new signing.properties file has been added to the assets/signing directory, providing a template for Android APK signing. It defines the keystore file path, alias, and placeholder fields for the store and key passwords, enabling users to configure their signing credentials for the build process.

assets/signing · high confidence

Introduced the \ScreensScreenBloc\ and its associated models and events to handle the state and logic for the Screens screen. This includes handling screen lifecycle events such as adding, deleting, modifying, and setting the initial screen, ensuring the UI state updates correctly when the underlying configuration changes.

_lib/presentation/screen/screens\screen/bloc · high confidence

The Platforms screen now has a dedicated BLoC that manages the state of platform selections (Mobile, Web, Windows, MacOS, Linux). Users can toggle these platforms in the UI, and the BLoC updates the global configuration accordingly, ensuring that the selected platforms are persisted and reflected in the app's behavior.

_lib/data/source/remote/figma, lib/presentation/screen/figma\_styles\_screen/bloc, lib/presentation/screen/platforms\screen/bloc · medium confidence

The application now supports English and Ukrainian languages. Users will see all interface text, error messages, and prompts translated into these two languages, with the generated localization files providing the necessary string resources for the app's UI.

lib/app/localization · high confidence

The template now includes English localization files (app\_en.arb and intl\_en.arb) containing translation keys for the app name, common UI labels (such as image source and camera options), and error messages for form validation, network failures, and Firebase authentication states. This provides the foundational English text for the application's internationalization system.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/app/localization · high confidence

A new utility class, FastlaneMakefileUtil, was added to handle the generation of Fastlane Makefiles. This component provides a standardized way to construct build commands with dynamic flavor, environment, and main Dart path parameters, supporting the broader Fastlane integration.

_lib/domain/service/fastlane\service/utils · high confidence

Introduced new Fastlane configuration files (Appfile, Fastfile, Pluginfile) for both Android and iOS platforms. The Android build lane now supports building APK/AAB artifacts, uploading to the Google Play Store, and distributing to Firebase App Distribution. The iOS build lane supports building iOS archives, uploading to TestFlight, and distributing to Firebase App Distribution. Both platforms now include automated Slack notifications for build status and generate changelogs using git-cliff.

assets/fastlane · high confidence

New enums have been introduced to manage Fastlane project structure and environment variables. The FastlaneAssets enum defines paths for core Fastlane files (Appfile, Fastfile, Pluginfile, and Gemfile), providing methods to resolve their asset and output paths based on the platform. Additionally, the FastlaneEnvVars enum lists specific environment variables required for Fastlane operations, including JSON key files, package and bundle identifiers, Firebase and App Store Connect IDs, Apple developer credentials, and a Slack webhook URL.

_lib/domain/service/fastlane\service/enums · high confidence

New utility classes have been introduced in the Fastlane service to automate the creation of configuration files and Makefile targets. FastlaneConfigParam and its implementations (FastlaneOneLineParam, FastlaneMultiLineParam) define structured parameters for generating YAML-style config files. FastlaneEnvsCreator handles the creation and writing of environment variable files. FastlaneFlavorParams formats flavor-specific parameters for configuration files. FastlaneGenerateMakefile generates platform-specific Makefile targets for building and distributing Android (APK/AAB) and iOS (TestFlight/Firebase) builds, integrating with the existing Makefile infrastructure.

_lib/domain/service/fastlane\_service/utils/fastlane\config · high confidence

A new utility class, PlatformEnvCreator, has been introduced to generate Fastlane environment files for iOS and Android. The implementation includes specific creators for each platform that initialize environment variables such as bundle IDs, Apple developer names, Firebase IDs, and Slack URLs. This change provides a standardized way to create and write platform-specific Fastlane environment configurations.

_lib/domain/service/fastlane\_service/utils/platform\_env\creator · high confidence

A new FastlaneService has been introduced to automate the creation of Fastlane configuration files and environment variables for Android and iOS platforms. The service generates platform-specific directories, copies necessary asset files, and writes a fastlane\_config.yaml file containing scheme and Firebase configurations. It also creates environment files with bundle/package IDs and flavor-specific settings, supporting both single and multi-flavor project setups.

_lib/domain/service/fastlane\service · high confidence

A new screen has been introduced to allow users to import Figma styles. This UI component provides input fields for a Figma file key and token, along with buttons to retrieve or clear styles, and includes navigation controls to proceed to the Swagger parser screen or return to the previous screen.

_lib/presentation/screen/figma\_styles\screen · high confidence

The application now supports importing design data from Figma, including node type conversion, node list parsing, and repository implementation for fetching files and nodes. Additionally, a new ScreenRepository has been introduced to manage the lifecycle of application screens, allowing for the addition, modification, and removal of screen definitions.

lib/data/repository · high confidence

Users can now generate Flutter style code from Figma designs. The new FigmaService fetches Figma files and nodes, then extracts text styles and color styles (including light/dark variants) to populate the app's style definitions.

_lib/domain/service/figma\service · high confidence

Introduced new pre-generation and post-generation hooks for the Flutter basic base brick. The pre-generation script handles the initial \flutter create\ command and initializes custom variables for the project. The post-generation script performs cleanup tasks such as removing unused platform directories, updating the \pubspec.yaml\ to reflect selected platforms, and running various build tools including \flutter\_launcher\_icons\, \intl\_utils\, \import\_sorter\, and \flutter\_native\_splash\. It also manages state management dependencies (BLoC, Provider, Riverpod, Signals, MVVM) and handles localization and flavor configurations.

_bricks/flutter\_basic\base/hooks · high confidence

The system now supports automatic changelog generation using GitCliff. This includes a new \GitCliffService\ that copies configuration files (TOML assets) to the project directory and updates the main Makefile with \release\_notes\ and \changelog\ targets. This enables users to generate release notes and changelogs directly from their project's git history.

_lib/domain/service/git\_cliff\service · high confidence

The remote authentication layer now uses a dedicated GraphQL client and request processor to handle login requests. The new \AuthSource\ interface and its \AuthSourceImpl\ implementation execute a \customerAccessTokenCreate\ mutation, mapping the response to \CustomerTokenResponseData\ and handling user errors.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/data/source/remote/auth · high confidence

A new Makefile has been added to the Flutter project template, defining the root directory and an assets directory for managing project assets.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/{{\#flavorizr}}Makefile{{ · high confidence

Introduced a new \PlatformsList\ domain entity that tracks the enabled status of six platforms (Android, iOS, Web, macOS, Windows, Linux) with sensible defaults (Android and iOS enabled). The entity provides helper properties to determine if the configuration is web-only or mobile-only, and offers methods to serialize the selected platforms into string lists or build commands, supporting serialization and deserialization via the freezed and json\_serializable packages.

_lib/domain/entity/platforms\list · high confidence

The generated project now includes a \Dimensions\ utility class in \lib/app/util/dimensions.dart\ to manage layout constants, and a \QaUtils\ class in \lib/app/util/qa\_utils.dart\ that provides a debug interface for setting a Charles proxy via a dialog. The \Dimensions\ class uses conditional generation to support screen-based sizing when the \screen\_util\ feature is enabled, while \QaUtils\ exposes a placeholder button and a dialog for entering proxy IP and port values.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/app/util · high confidence

A new abstract class, ReusableRouteFlow, has been added to the project template to simplify the implementation of multi-step navigation flows using GoRouter. This class provides built-in methods to start, navigate forward, navigate backward, and finish a flow, automatically handling the return to the original route. Developers can now extend this class to create reusable, state-managed navigation sequences without manually tracking flow state or managing the root navigator key.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/app/router/{{\#isGoRouter}}flow{{ · medium confidence

A new 'Screens' screen has been added to the application, allowing users to view, add, modify, and delete project screens. The screen displays a sorted list of screens in a table format, with options to add new screens via a modal dialog, modify existing ones, delete them, or set a screen as the initial one. The UI includes navigation buttons to proceed to the styles screen or go back to project settings, and handles errors such as duplicate screen names or invalid screen names with appropriate error dialogs.

_lib/presentation/screen/screens\screen · high confidence

A new GitLab CI/CD pipeline configuration has been added to the project template, introducing automated SonarQube static analysis for the main, develop, and merge request branches. The pipeline includes a build stage that runs Flutter dependency resolution and the SonarQube scanner, with a separate job to decorate merge requests with analysis results.

_bricks/flutter\_clean\base/\\brick\\_/{{project\_name.snakeCase()}}/{{\#use\sonar}}.gitlab-ci.yml{{ · high confidence

A new screen has been introduced to allow users to import and parse a Swagger/OpenAPI specification via a URL. The interface includes a text field for the API URL and handles the parsing process, including a dialog to resolve duplicate component conflicts and error handling for invalid URLs.

_lib/presentation/screen/swagger\_parser\screen · high confidence

A new set of use cases has been introduced in the domain layer to manage Swagger data. This includes operations to add, edit, and delete data objects, source requests, and sources, as well as fetching and restoring components. These use cases act as the domain-side interface for interacting with the Swagger repository, enabling the creation and modification of API components and source configurations.

lib/domain/usecase/swagger · high confidence

The data components screen now includes new widgets to display and manage API requests and their associated sources. A new \SourceItem\ widget renders a collapsible section for each source, listing its requests and providing controls to add, edit, or delete them. The \RequestsSection\ and \RequestItem\ widgets handle the visual representation of individual requests, including their input parameters (body, form data, query/path parameters) and response bodies, along with edit and delete actions.

_lib/presentation/screen/data\_components\_screen\v2/widget/sources · high confidence

The generated project now includes an AppService that performs a one-time initialization, including an optional jailbreak/root detection check. Environment variables (APIKEY1, APIKEY2) are loaded from a .env file using the envied package with obfuscation enabled. Additionally, a HiveCipherKeyService is provided to generate and securely store a symmetric key for Hive encryption, ensuring data protection at rest.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/app/service · high confidence

The template now includes three new files in the app layer: app\_initialization.dart provides a singleton Initialization class that bootstraps the app by initializing Firebase (when the firebase\_auth feature is enabled), setting up dependency injection, and initializing the database; banned\_app.dart introduces a BannedApp widget that displays a message about jailbroken or rooted devices, serving as a security measure; constants.dart adds a Constants class with a filterParamAll constant. These changes add new capabilities for app startup, device security, and shared constants.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/app · medium confidence

New repository interfaces have been introduced to handle authentication and token management. The \FirebaseAuthRepository\ defines methods for creating accounts, logging in, and logging out. The \RefreshTokenRepository\ provides a method to refresh authentication tokens. The \TokenRepository\ manages access and refresh tokens, including clearing and updating authentication data. These interfaces establish the domain layer contracts for authentication flows.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/domain/repository · high confidence

New mappers are now available to convert remote authentication responses into domain entities. The \AuthenticationMappers\ class provides methods to map both standard and refresh token responses to the \Authentication\ entity, ensuring consistent transformation of access and refresh tokens.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/data/mapper · high confidence

The template now includes several new reusable widgets in the core architecture layer: ClickableWidget for styled tap interactions, EnsureVisibleWhenFocused to auto-scroll focused fields into view, ScrollRootMax and ScrollRootMin for flexible scrolling containers, ThemeModeSwitcher for managing theme state, CustomToast for displaying messages, and FlavorBanner to display environment banners in development builds.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/core/arch/widget · high confidence

The Flutter project template now includes several new configuration files to improve code quality and build processes. A comprehensive \analysis\_options.yaml\ is added to enforce strict linting rules and code standards. SonarQube integration is supported via \.gitlab-ci.yml\ and \sonar-project.properties\ for automated code analysis. Additionally, \flutter\_native\_splash.yaml\ configures app splash screens, \pubspec.gen.yaml\ manages dependencies and assets, and \l10n.yaml\ sets up localization. These changes provide a more robust foundation for development and CI/CD pipelines.

_bricks/flutter\_basic\base/\\brick\\_ · medium confidence_

New theme files (theme\_dark.dart, theme\_light.dart) and a central export file (theme\_imports.dart) were added to the presentation style layer. These files define the visual appearance of the application in both dark and light modes, including background colors, dialog styling, and custom theme extensions for colors and text styles.

lib/presentation/style/theme · high confidence

The template now includes three new domain-layer use cases: CreateAccountUseCase, LoginUseCase, and LogOutUseCase. Each use case encapsulates the logic for its respective authentication flow, delegating to the FirebaseAuthRepository and updating the FirebaseSessionService upon success.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/domain/usecase · high confidence

A new \FlavorGenerator\ service has been introduced to automate the process of adding and configuring app flavors in Flutter projects. This service detects existing configurations, manages platform-specific settings (Android, iOS, macOS), and orchestrates the \flutter\_flavorizr\ tool to generate flavor-specific code, assets, and build configurations. It also handles the necessary code modifications to support multiple app variants within a single project.

_lib/domain/service/file\_generator\_service/flavor\generator · high confidence

A new l10n.yaml configuration file has been added to the project template, defining the ARB directory as lib/app/localization/l10n, the template ARB file as app\_en.arb, and the output localization file as app\_localizations.dart. This enables the use of the handLocalization feature for managing app translations.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/{{\#handLocalization}}l10n.yaml{{ · high confidence

A new DMG (Disk Image) installer configuration has been added for the Onix Flutter Project Generator. The \installers/dmg\_creator/config.json\ file defines the layout of the installer, specifying the application icon, the title 'Onix Flutter Project Generator', and the placement of the app within the installer image. Additionally, \installers/README.md\ was added to provide documentation on how to create the DMG installer using the specified command.

installers · high confidence

The application now includes four new domain use cases for executing external processes: GetBranchesProcessUseCase retrieves Git branch information, GetSigningFingerprintUseCase extracts SHA1 and SHA256 signing fingerprints, RunOsaScriptProcessUseCase manages macOS terminal scripts for FlutterFire configuration, and RunProcessUseCase provides a generic command runner. These additions enable the generator to interact with the host system's tools for project setup and configuration.

lib/domain/usecase/process · high confidence

Users can now view detailed information about data components through a new ObjectDialog that displays an object's name and its variables, and see a list of objects via ObjectItem which displays component names, edit/delete actions, and variable details including enum values and type declarations.

_lib/presentation/screen/data\_components\_screen\v2/widget/objects · high confidence

The flutter\_clean\_base brick now includes new pre\_gen and post\_gen hooks that automate project initialization and cleanup. The pre\_gen hook creates the initial Flutter project structure and initializes custom variables, while the post\_gen hook removes unused platform directories, strips out unselected state management dependencies (e.g., Bloc, Provider, Riverpod, Signals), and runs formatting, import sorting, and splash screen generation. This ensures the generated project only contains the dependencies and platform configurations explicitly selected by the user.

_bricks/flutter\_clean\base/hooks · high confidence

Introduced the ProjectNameScreen, a new UI for configuring project name and organization. The screen includes input fields for the project name and organization, each with specific input formatters and validation logic. It also features a branch selector widget for selecting a branch, and navigation buttons to proceed or go back. The screen integrates with the application's localization for labels and helper text, and uses a BLoC pattern for state management.

_lib/presentation/screen/project\_name\screen · high confidence

The project now includes new data models for handling remote authentication and token operations. Specifically, \AuthenticationRequest\ and \AuthenticationResponse\ classes have been added to manage login credentials and token responses using the \freezed\ package. Additionally, a set of models for customer access tokens (\CustomerAccessToken\, \CustomerAccessTokenCreateResponse\, \CustomerCreateAccessTokenResponse\, \CustomerTokenResponseData\, and \CustomerUserErrorResponse\) have been introduced to support token creation and error handling, alongside a \TokenRequest\ model for refresh operations.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/data/model · high confidence

The generated project now includes concrete repository implementations for Firebase authentication, refresh tokens, and access/refresh token storage. FirebaseAuthRepositoryImpl handles user creation, login, and logout via the Firebase auth source, while RefreshTokenRepositoryImpl provides a placeholder for token refresh logic. TokenRepositoryImpl manages secure storage of access and refresh tokens, including methods to update, clear, and retrieve them.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/data/repository · high confidence

The file generator service now includes dedicated code generators for generating screen implementations across a wider range of state management patterns. New generators have been added for BLoC, Cubit, MVVM, Provider, Riverpod (both stateful and stateless), and the Signals library (both passive and reactive modes). Additionally, the base \ScreenCodeContent\ class has been updated to support route generation for both GoRouter and AutoRoute navigation libraries, allowing the boilerplate to adapt to the user's chosen routing solution.

_lib/domain/service/file\_generator\_service/screen\generators/gen · high confidence

The code generator now supports creating screen implementations for BLoC, DI, Provider, Riverpod, Signals, and ViewModel patterns. New mixin classes (BlocContentMixin, DIContentMixin, ProviderContentMixin, RiverpodContentMixin, SignalsContentMixin, and ViewModelContentMixin) each generate the corresponding Dart code for screen state management, including imports, class definitions, and dependency injection registration.

_lib/domain/service/file\_generator\_service/screen\generators/gen/mixins · high confidence

The screens screen now includes new widgets for managing screens: AddScreenDialog for creating or editing a screen's name and state management variant, ScreenTable to display the list of screens with options to set them as initial, modify, or delete, and Cell for table cell styling.

_lib/presentation/screen/screens\screen/widgets · high confidence

Users can now add or edit source names via a new AddEditSourceDialog, and delete requests with granular control over request body and response components using the DeleteRequestDialog.

_lib/presentation/screen/data\_components\_screen\v2/widget/dialogs · high confidence

The application now includes dedicated use cases for generating Fastlane and Git-Cliff configuration files. The new \GenerateFastlaneFilesUseCase\ handles Fastlane generation, including logic to skip generation during project modification, while the \GenerateGitCliffFilesUseCase\ manages Git-Cliff file generation. Both use cases provide user feedback on the success or failure of the generation process.

lib/domain/usecase/fastlane · high confidence

The lib/util directory now includes several new utility classes: Commands for generating shell and mason commands, ProcessRunner for executing external processes with output handling, ExtraSpaceFormatter for text input normalization, FlavorsUtil for managing flavor configurations, ProjectNameValidator for checking project name validity, ReservedWordProcessor for handling Dart reserved words, StreamUtil for stream operations, and TypeMatcher for mapping type definitions to Dart equivalents and default values.

lib/util · high confidence

New extension methods have been added to the \lib/app/util/extenstion\ directory to support the Swagger refactoring and data component generation. \SwaggerVersionExtension\ parses Swagger/OpenAPI versions (2 or 3) from JSON maps. \SwaggerTypeExtension\ and \SwaggerReferenceExtension\ handle type mapping (e.g., 'string' to 'String') and mapper import/declaration generation. \VariableNameExtension\ provides string cleaning for operation IDs, component names, and paths. \DataComponentsExtension\ adds a \distinct()\ method to filter duplicate data objects. \DynamicExtension\ assists in converting dynamic maps to typed lists. \StringExtensions\ and \ContentKeyExtension\ provide string manipulation and content key validation. \VariableSortExtension\ allows sorting data variables by required status.

lib/app/util/extenstion · high confidence

New extension methods have been introduced in the lib/util/extension directory to support various utility functions. These include adding new lines to string collections, detecting Flutter project directories, displaying signing failure dialogs, parsing flavor strings, formatting output messages, stripping request/response suffixes from strings, and converting version strings to integers for comparison.

lib/util/extension · high confidence

The application's dependency injection has been consolidated into a structured, modular system. Core services (Output, FileGenerator, Docs, Figma, Fastlane, GitCliff) and repositories (Screen, Figma, Swagger) are now registered in dedicated DI files, making the codebase easier to maintain and extend. Additionally, all BLoC and Cubit instances for the UI screens (such as SwaggerParser, DataComponents, and various dialogs) are now centrally registered, ensuring consistent access to business logic across the application.

lib/core · high confidence

The app now uses dedicated theme extension classes for colors and text styles, enabling consistent styling across the UI. Users will see a unified visual design where colors (such as dark, control, text, contrast, faded, alarm, and dark contrast) and text styles (including various font sizes and weights) are managed through a centralized theme system that supports both light and dark modes.

_lib/presentation/style/theme/theme\extension · high confidence

The file generator service now produces dedicated Dart classes for theme colors and text styles, supporting both standard Flutter and Tailor-based implementations. Specifically, it generates \app\_colors.dart\ and \theme\_colors.dart\ files that define \AppColors\ and \ThemeColors\ classes, as well as \theme\_text\_styles.dart\ for \ThemeTextStyles\. These generators handle light and dark theme variants, sort and deduplicate color and text style entries, and integrate with the project's presentation layer. The Tailor-specific generators (\theme\_colors\_file\_content\_tailor.dart\ and \theme\_text\_styles\_file\_content\_tailor.dart\) also include necessary imports and annotations for the Tailor mixin.

_lib/domain/service/file\_generator\_service/style\generator/gen · high confidence

A new \ArchType\ enum is introduced with \clean\ and \basic\ variants. This enum provides extension methods that return architecture-specific paths for dependency injection, logging, entities, models, GraphQL, mappers, and enums, and defines the list of supported state managers for each architecture (e.g., \basic\ supports \viewModel\ while \clean\ does not).

_lib/domain/entity/arch\type · high confidence

Added the BLoC implementation for the Summary screen, including the main bloc class, event/state models, and generated freezed code. The bloc initializes by fetching screen data via the ScreenRepository and updating the state with configuration from the ConfigService.

_lib/presentation/screen/summary\screen/bloc · high confidence

Added the ComponentGeneratorService, which automates the creation and modification of source files, repositories, and related components. The service now handles file operations via a new FileMixin and FileOperationResult enum, supporting both creation and modification of generated code artifacts.

_lib/domain/service/component\generator · high confidence

Added ConfigService to centralize the state of project configuration, including screens, components, and various feature flags (e.g., Firebase Auth, GraphQL, Sentry). The service tracks modification states for projects, screens, and components, and provides methods to update, save, and retrieve configuration data, including generating signing passwords and managing flavor settings.

_lib/domain/service/config\service · high confidence

Added a new DocsService that automatically generates project documentation files (README, CHANGELOG, architecture overview, installation instructions, and technical descriptions) within the project structure. The service supports flavor-based configuration, allowing users to generate documentation that reflects their specific app flavors, platforms, and build commands. This provides a consistent starting point for project documentation.

_lib/domain/service/docs\service · high confidence

A new FileGeneratorService has been added to the domain layer, acting as a central orchestrator for generating various project components. It manages specialized generators for default screen routes, styles, signing configurations, and application flavors. The service also includes a utility method to pre-create empty source folders for future use, supporting a more modular and organized code generation process.

_lib/domain/service/file\_generator\service · high confidence

Added new Dart classes (MakefileBase, MakefileContent, MakefileLine) in the lib/util/makefile directory to support generating Makefile content. These utilities provide a structured way to define and convert Makefile commands and dependencies into string arrays, facilitating automated Makefile creation.

lib/util/makefile · high confidence

The Swagger parser screen now features a dedicated BLoC implementation that manages the parsing workflow. Users can initiate a parse, view the fetched components, and cancel the operation. The screen handles state transitions for initialization, parsing (including empty URL handling), and cancellation, leveraging use cases for fetching and restoring components.

_lib/presentation/screen/swagger\_parser\screen/bloc · high confidence

Added a new remote data source that fetches and parses Swagger (OpenAPI) definitions from a remote URL. The implementation handles parsing models, paths, and tags, with specific logic to process 'allOf' references and extract tags from paths if the 'tags' key is empty or missing. This provides the foundation for generating code from remote Swagger specifications.

lib/data/source/remote/swagger · high confidence

Added new abstract interfaces for base and screen generation services, establishing a generic structure for generation operations. The new \BaseGenerationService\ defines a generic \generate\ method, while \ScreenGenerationService\ extends it to specifically handle \ScreenGeneratorParams\.

lib/domain/service/base · high confidence

Added a new \AppRouter\ class in \lib/app/router/app\_router.dart\ that defines the application's navigation structure. This change introduces a centralized routing configuration using the \go\_router\ package, mapping specific URL paths to corresponding screen widgets, including the new \EditProjectScreen\ and \DataComponentsScreenV2\.

lib/app/router · high confidence

The app now initializes with a centralized App widget that configures the Material app with dark theme as the default, sets up localization delegates, and integrates the app router and loader overlay. Global dependency injection is initialized via AppInitialization. Shared UI utilities are added, including a ClickableWidget for consistent touch feedback, a Delimiter for spacing, and a CustomToast helper for displaying messages. App constants and Swagger-related keys are centralized in dedicated files.

lib/app · high confidence

Added new domain entities for managing application styles, including a base AppStyle class with validation logic for style names, an AppColorStyle entity for color definitions, and an AppTextStyle entity that maps font properties (family, size, weight, letter-spacing, and color) to Flutter's TextStyle, with support for Google Fonts.

_lib/domain/entity/app\styles · high confidence

A new local data source for configuration management has been added. The \ConfigSource\ abstract class and its \ConfigSourceImpl\ implementation provide methods to read and write configuration data to local files, enabling the application to persist and retrieve settings from the local filesystem.

lib/data/source/local · high confidence

Added a new set of domain entity classes in the \lib/domain/entity/component\ directory to represent data objects, enum parameters, and request/response structures. This includes the abstract \Component\ base class, concrete implementations like \DataObjectComponent\, \EnumParamComponent\, and \RequestComponent\, along with their corresponding Freezed-generated serialization and copy-with methods. These components enable the system to parse, store, and serialize Swagger-based API definitions into structured domain models, supporting features such as JSON serialization/deserialization, path and query parameter handling, and enum type mapping.

lib/domain/entity/component · high confidence

Users can now select multiple target platforms via a new grid layout displaying each platform as a selectable checkbox. The \PlatformCheckbox\ widget renders an SVG icon and label, while \PlatformScreenBody\ arranges them in a 3-column grid, reflecting the current state of each platform in the \PlatformsList\.

_lib/presentation/screen/platforms\screen/widgets · high confidence

Added new domain entity classes to represent specific failure states for flavorizing, JSON parsing, signing, and Swagger parsing. Each class implements a common Failure interface and provides localized error messages via extension methods, enabling more granular error handling and user-facing feedback for these distinct operations.

lib/domain/entity/failure · high confidence

Added new files in the state management domain to support multiple state management strategies (Bloc, Cubit, Provider, Riverpod, Signals, MVVM, and base) for code generation. The \project\_state\_manager.dart\ file defines an enum mapping each strategy to its corresponding implementation, while \state\_management\_variant.dart\ introduces a sealed class hierarchy representing different state management variants, each associated with a specific screen generation service. This enables the application to dynamically select and generate code based on the chosen state management approach.

_lib/domain/entity/state\management · high confidence

Added new data model classes to represent Swagger types, including a sealed hierarchy for request types (request body, multipart, query, and path parameters) and response types. The core SwaggerType system now supports serialization to and from JSON, handling variables, references, arrays, enums, files, and allOf compositions. This provides a structured foundation for generating Dart code from Swagger specifications.

lib/data/model/swagger/types · high confidence

Added new parameter classes, ScreenGeneratorParams and DefaultScreenRouteGeneratorParams, to encapsulate the data required for generating screens and routes. These classes bundle project metadata (path, name), the selected architecture (ArchType), and routing configuration (ProjectRouter), providing a structured way to pass generation context to the file generator service.

_lib/domain/service/file\_generator\_service/screen\generators/params · high confidence

Added the \ProcedureSelectionScreenBloc\ along with its associated events, states, and models to manage the logic for the procedure selection screen. This includes handling project initialization, opening and creating projects, managing locale changes, and generating Android signing configurations and flavors.

_lib/presentation/screen/procedure\_selection\screen/bloc · high confidence

Added a new GenerationScreen and its associated BLoC, models, and UI widgets to handle the project generation process. This change introduces the core logic for initializing the generation state, running build processes (such as downloading bricks and running Mason commands), and managing the output stream. The UI displays a console for live output and provides controls to open the generated project in Android Studio or close the screen, effectively centralizing the generation workflow previously handled by other components.

_lib/presentation/screen/generation\screen · high confidence

Added a new base \ClassBuilder\ class and two specialized implementations, \FreezedClassBuilder\ and \JsonClassBuilder\, to handle code generation for immutable data classes and JSON serialization respectively. These components provide structured ways to generate Dart code for data models, supporting features like snake\_case/pascal\_case naming conventions, import management, and optional JSON serialization methods.

_lib/domain/service/base/class\builder · high confidence

A new DataComponentsScreenV2 is introduced, providing a dedicated interface for managing data components and sources. Users can now parse Swagger files to automatically generate components, as well as manually add, edit, or delete sources and components through dedicated dialogs. The screen integrates with the application's BLoC state management to handle CRUD operations and error states, specifically handling Swagger parser failures.

_lib/presentation/screen/data\_components\_screen\v2 · high confidence

A new implementation of the data components screen (v2) has been added, providing full Create, Read, Update, and Delete (CRUD) capabilities for source components, data objects, and requests. This includes adding and editing sources, deleting components and requests, and fetching component data via a dedicated BLoC.

_lib/presentation/screen/data\_components\_screen\v2/bloc · high confidence

The template now includes two new files, \app\_route.dart\ and \app\_route\_location.dart\, which define the \AppRoute\ and \AppRouteLocation\ enums. These provide a structured, type-safe way to manage navigation paths and security states (e.g., \auth\, \securedApp\) within the GoRouter setup, replacing or supplementing previous string-based or less structured routing definitions.

_bricks/flutter\_clean\base/\\brick\\_/{{project\_name.snakeCase()}}/lib/app/router/{{\#isGoRouter}}app\_route.dart{{, bricks/flutter\_clean\base/\\brick\\_/{{project\_name.snakeCase()}}/lib/app/router/{{\#isGoRouter}}app\_route\location.dart{{ · high confidence

The project now includes a new dependency injection setup in \lib/core/di/\, which registers and provides access to key services and repositories. This includes local storage sources (preferences, secure storage), remote API clients (Dio, GraphQL, Firebase Auth), repositories (token, Firebase Auth), and use cases (login, create account, log out). The DI container is initialized via \initializeDi\, which calls individual registration functions for each layer, making these dependencies available throughout the application.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/core/di · high confidence

A new dialog has been added to the \classes\_from\_json\_dialog\ module, enabling users to paste JSON and generate corresponding class code. The feature includes a primary dialog for JSON input and keyboard handling (Escape key support), and a secondary view for displaying and copying the generated code. The implementation introduces a \ClassFromJsonDialogCubit\ that orchestrates the parsing and code generation, utilizing a \JsonParser\ to process the input and return the resulting Dart classes.

_lib/presentation/screen/procedure\_selection\_screen/widget/classes\_from\_json\dialog · high confidence

A new JsonParser class has been introduced to handle the parsing of JSON strings into DataObjectComponent and DataVariableComponent structures. The parser recursively processes nested maps and lists, and specifically handles null, empty maps, and empty lists by treating them as 'UndefinedValue' types, ensuring these edge cases are correctly represented in the generated data models.

_lib/domain/service/json\parser · high confidence

A new OutputService class has been added to manage output lines. It provides a stream of OutputLine objects and maintains a list of all output lines, allowing users to add new lines or clear the existing ones.

_lib/domain/service/output\service · high confidence

Introduced the ProcedureSelectionScreen, a new UI component that allows users to initiate a new project by selecting a directory path. The screen provides options to generate Android signing configurations, create Flutter flavors, and generate classes from JSON, with error handling for signing and JSON parsing failures.

_lib/presentation/screen/procedure\_selection\screen · high confidence

A new ProjectSettingsScreen has been added to the application, providing a dedicated interface for managing project configuration. The screen features a two-column layout with LeftPart and RightPart widgets, allowing users to input and view settings such as flavors. It includes navigation controls to proceed to the screens configuration or go back to the platforms screen, integrating with the existing GoRouter-based navigation and BLoC state management architecture.

_lib/presentation/screen/project\_settings\screen · high confidence

A new \SwaggerMapper\ class has been introduced in \lib/data/mapper/swagger/swagger\_mapper.dart\ to handle the conversion of Swagger/OpenAPI specifications into internal domain models. This mapper provides methods to map data objects, extract enum parameters, and generate source components (including a default source when no tags are present), effectively centralizing the logic for transforming Swagger responses into structured components like \DataObjectComponent\, \EnumParamComponent\, and \SourceComponent\.

lib/data/mapper/swagger · high confidence

The lib/presentation/widget/inputs directory now includes three new reusable input components: LabeledCheckbox, LabeledSegmentedControl, and TextFieldWithLabel, enabling consistent form rendering with theme-aware styling. Additionally, SwitchWithLabel was moved from lib/presentation/widgets/ to lib/presentation/widget/inputs and refactored from a StatefulWidget to a StatelessWidget, adopting the new theme extension for colors and text styles.

lib/presentation/widget/inputs · high confidence

Added four new Flutter widget components in the presentation layer: AppActionButton, AppFilledButton, NavigationButtonBar, and RemoveButton. AppFilledButton supports dynamic text sizing via AutoSizeGroup, hover/focus states, and icon placement. NavigationButtonBar provides a standard next/previous button pair. These components standardize button styling and interaction patterns across the application.

lib/presentation/widget/buttons · high confidence

The data components screen now uses a new \DataComponentsContent\ widget that organizes the UI into two distinct sections: a list of sources and a list of data components (enums and data objects). The data components are displayed in a sorted list using \ObjectItem\ widgets, each supporting edit and delete actions. If no data components are present, a localized 'no data components' message is shown. A new \SectionHeader\ widget provides consistent styling for section titles. This change introduces the structural layout for managing and displaying data components in the v2 screen.

_lib/presentation/screen/data\_components\_screen\v2/widget · high confidence

A new AddEditComponentDialog widget has been introduced, providing a user interface for creating and modifying data components. This dialog allows users to specify component names, toggle enum types, and add variables, with built-in validation for character restrictions and duplicate names.

_lib/presentation/screen/data\_components\_screen\_v2/widget/dialogs/add\_edit\_component\dialog · medium confidence

Users can now configure signing variables and manage application flavors through new dialog interfaces. The \SigningDialog\ allows users to input and validate certificate details (name, organization, city, state, country, and password) with real-time validation feedback. The \FlavorsDialog\ enables users to add, remove, and validate application flavor names. Both dialogs integrate with a new \OkCancelKeyboardListener\ to support keyboard navigation (Enter/Escape) and ensure focus management within the dialog content.

lib/presentation/widget/dialogs · high confidence

The add request params dialog now features dedicated UI components for managing parameters. A new \AddParamDialog\ widget provides a form for adding parameters with support for list types, type selection via a searchable dropdown, and input validation. Additionally, \ParamsPreview\ and \ClassPreview\ widgets have been introduced to display and allow editing or deletion of existing parameters and class/enum variables, giving users the ability to review and modify request configurations directly within the dialog.

_lib/presentation/screen/data\_components\_screen\_v2/widget/dialogs/add\_request\_params\dialog/widgets · high confidence

Users can now add and edit variables within components using the new AddEditVariableDialog, which supports list types and search in dropdowns. A ClassPreview widget displays the generated class structure with edit and delete actions for each variable. Additionally, a PasteJsonDialog allows users to import data by pasting JSON directly.

_lib/presentation/screen/data\_components\_screen\_v2/widget/dialogs/add\_edit\_component\dialog/widgets · high confidence

Added new domain entities in the config module to support project settings and output formatting. The \Config\ class now includes a \BranchConfig\ for managing branch and version details, alongside fields for architecture (\ArchType\), state management, platform lists, and feature flags (e.g., \sentry\, \graphql\, \firebaseAuth\). Additionally, \Fingerprint\ and \OutputLine\ entities were introduced to handle project fingerprints and structured console output with color and tag information.

lib/domain/entity/config · high confidence

The application now includes new domain repository interfaces to manage data sources and UI components. A FigmaRepository has been added to fetch Figma file and node data. A ScreenRepository has been introduced to manage the set of application screens, including operations to add, remove, and modify them. A SwaggerRepository has been added to handle Swagger data fetching, component management (add, edit, delete), and source configuration, supporting the refactoring of the data components generation.

lib/domain/repository · high confidence

The domain layer now includes dedicated use cases for generating project flavors, screens, signing configurations, and styles, as well as retrieving Figma styles. Each use case encapsulates the logic for its respective generation task, delegating to specific services like FileGeneratorService, OutputService, ScreenRepository, and FigmaService. This introduces new capabilities for automated file generation across multiple project aspects.

_lib/domain/usecase/file\generation · high confidence

The project's logging system has been replaced with a new, modular architecture. Developers now have access to a unified \AppLogger\ interface with methods for fatal, error, warning, info, debug, and trace logs, as well as a dedicated \AppDioLogger\ for HTTP client operations. The implementation (\AppLoggerImpl\) integrates with Firebase Crashlytics for production error tracking, with a utility class (\CrashlyticsUtil\) managing the reporting. Additionally, the \LoggerFactory\ provides specialized logger configurations for network, feature-specific, and performance monitoring scenarios, while \AppConsoleLogOutput\ and \AppCrashlyticsLogOutput\ handle the actual output routing.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/core/arch/logger · high confidence

Added three new use cases for managing application output: AddOutputMessageUseCase to add messages, ClearOutputUseCase to clear the output, and GetGenerationOutputStreamUseCase to retrieve the output stream with progress line filtering. These components enable the application to handle and display generated content through a structured service layer.

lib/domain/usecase/output · high confidence

Added five new Flutter widgets to the presentation layer: ColoredLine for rendering styled text lines, OkCancelKeyboardListener for handling Enter/Escape key events in dialogs, OutputConsole for displaying a stream of output lines, TitleBar for consistent header styling, and TooltipWrapper for displaying contextual help tooltips.

lib/presentation/widget · high confidence

The code generator now supports multiple state management architectures, each with its own strategy implementation. New strategy classes—Base, Bloc, MVVM, Provider, Riverpod, and Signals—have been added to the \lib/domain/service/strategy\ directory. Each strategy defines a set of \StateManagementVariant\ options (e.g., Stateful, Stateless, Bloc, Cubit, Mvvm, Provider, Riverpod, Signals) that determine how screens are generated. This allows users to select their preferred state management pattern when generating new screens.

lib/domain/service/strategy · high confidence

Added new text input formatters to enforce specific formatting rules for user input. The \FirstCharacterNotDigitFormatter\ prevents text fields from starting with a digit. The \LowerCaseFormatter\ automatically converts all input to lowercase. The \MethodNameFormatter\ ensures method names start with a lowercase letter or underscore, contain only alphanumeric characters and underscores, and never start with a number. The \PascalCaseFormatter\ converts input to PascalCase using the \recase\ library. The \PathFormatter\ normalizes file paths by replacing backslashes with forward slashes, ensuring paths start with a slash, have lowercase first letters after the slash, remove consecutive slashes, and filter out invalid path characters.

lib/app/util/formatters · high confidence

The procedure selection screen now includes a new tools menu that lets users generate Android signing keys, create Flavors, and generate classes from JSON. The UI for these features has been added, including a fingerprint dialog for displaying signing information and an output console for generation tasks.

_lib/presentation/screen/procedure\_selection\screen/widget · high confidence

A set of new utility enums has been added to the codebase to support project configuration and tooling options. These include FingerprintType (sha1, sha256), GenerationState (init, generating, waiting), OutputType (info, error, progress, message), ProjectLocalization (intl, flutterGen), ProjectRouter (goRouter, autoRouter), ProjectTheming (manual, themeTailor), and ToolType (generateAndroidSigning, generateFlavors, generateClassesFromJson). These enums provide structured options for various aspects of the application's setup and operation.

lib/util/enum · high confidence

Added three new extension files in the app's extension directory to provide convenient utility methods. A Logger extension was added to handle crash logging with support for reasons, errors, and stack traces, with a placeholder for future crash recognition integration. A Process extension was added to map process output and error lines to an OutputService. A BuildContext extension was added to easily access screen width, height, and status bar height.

lib/app/extension · high confidence

Three new extension files have been added to the project template to provide convenient utility methods. The \theme\_brightness\_extension.dart\ file adds a \switchThemeBrightness\ method to \BuildContext\ for toggling between light and dark modes, and an \isDarkMode\ getter. The \orientation\_extension.dart\ file adds static methods to \SystemChrome\ to lock the screen to portrait, landscape, or unlock all orientations. The \failure\_message\_extension.dart\ file adds \getApiFailureMessage\ and \getFirebaseFailureMessage\ methods to \BuildContext\ to convert API and Firebase errors into localized user-facing strings.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/app/util/extension · high confidence

The generator now offers a new 'Basic' architecture with a simplified three-layer structure (app, data, presentation) and integrates MVVM with a Signals-based state management solution. Users can now add application flavors via a standalone generator, add screens to existing projects, and view data component previews parsed from Swagger. Environment variable handling has been secured by replacing flutter\_dotenv with the envied package. Additionally, the project includes a Makefile for build and code generation tasks, git-cliff configuration for automated changelog generation, and updated linting rules.

(repo-wide) · high confidence

The project settings screen has been updated to handle a comprehensive set of configuration options, including flavors, signing keys, Sonar, GraphQL, state management, router, localization, theming, Firebase, screen utility, Sentry, and architecture type. Users can now adjust these settings directly from the project settings interface, with the BLoC managing state changes and persisting updates to the configuration service.

_lib/presentation/screen/project\_settings\screen/bloc · high confidence

The project settings screen has been refactored into dedicated widgets (arch\_selector, state\_selector, left\_part, right\_part) to configure project architecture, state management, router, localization, theming, and other features. Users can now select the project architecture (ArchType) and state management strategy (ProjectStateManager) via dropdowns, with validation that warns if the current screen configuration is incompatible with the selected architecture or state manager.

_lib/presentation/screen/project\_settings\screen/widgets · high confidence

The default logo (assets/logo.svg) has been updated with a simplified SVG structure and adjusted viewBox, while a new white variant (assets/logo\_white.svg) has been added. Additionally, a PDF icon asset (assets/icon.ai) was added to the assets directory.

assets · high confidence

The \main\_page.dart\ file, which contained the \MainPage\ widget and its state, has been removed from the codebase. This eliminates the UI component responsible for the project configuration form, including fields for project name, organization, flavors, router, localization, and other generation options.

_lib/presentation/screens/main\page · high confidence

The template now includes a new Authentication entity in the domain layer, defining accessToken and refreshToken fields using the freezed\_annotation package. The class is annotated with @freezed and includes a fromJson factory method and an empty() constructor, indicating support for immutable data classes and JSON serialization consistent with Freezed v3.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/domain/entity · high confidence

The presentation layer now includes dedicated theme files for dark and light modes, each configuring scaffold backgrounds and applying custom extensions for colors and text styles. A new extension on BuildContext provides convenient access to these theme extensions (ThemeColors and ThemeTextStyles) via the theme's extension mechanism, simplifying access to design tokens throughout the app.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/presentation · high confidence

The flavor generation service now includes new mixins to handle flavor-specific configuration and asset management. The \FlavorGeneratorUtilsMixin\ provides methods to extract the organization ID from Android and iOS project files, copy flavor-specific launcher icons and splash images, correct Apple platform configurations, and generate a flavor banner widget. The \FlavorInjectorMixin\ handles the injection of flavorizer configuration into the \pubspec.yaml\ file, supporting both generated and existing projects by adding flavor dimensions, app names, bundle IDs/application IDs, and icon paths for each defined flavor.

_lib/domain/service/file\_generator\_service/flavor\generator/mixins · high confidence

The macOS build now automatically registers several new Flutter plugins, including connectivity\_plus, file\_selector\_macos, flutter\_secure\_storage\_macos, package\_info\_plus, path\_provider\_foundation, shared\_preferences\_foundation, and url\_launcher\_macos. This enables the application to utilize features such as network status checks, file system access, secure storage, package information retrieval, and URL launching on macOS.

macos/Flutter · high confidence

New utility enums have been introduced to support Swagger parsing and data type conversions. This includes a mapping between Dart types and Swagger types (e.g., String to string, int to integer), enums for file types (request, response, entity), mapper types for entity transformations, and specific enums for Swagger path inputs, HTTP request types, and Swagger versions.

lib/app/util/enum · high confidence

A new parameter class, ComponentGeneratorParams, has been added to the component generator service. This class encapsulates the necessary context for generating components, including the project name, root path, architecture type (ArchType), specific components to generate, and a flag indicating if the project already exists. This change supports the ongoing refactoring of the Swagger parsing and data component generation logic.

_lib/domain/service/component\generator/params · high confidence

A new \AppThemeColors\ class has been added to define the application's color scheme, including contrast, dark, control, text, faded, and alarm colors. This establishes a centralized palette for the UI, replacing any previous ad-hoc color usage.

lib/presentation/style · high confidence

The style generator service now uses dedicated parameter classes to pass configuration data, replacing previous ad-hoc or less structured approaches. New classes including StylesGeneratorParams, ColorsGeneratorParams, ThemeColorsGeneratorParams, and ThemeTextStyleGeneratorParams are introduced, each implementing BaseGenerationParams. These classes encapsulate specific properties such as project name, project path, project existence status, theming mode, useScreenUtil flag, and lists of AppColorStyle or AppTextStyle objects. This change provides a more explicit and type-safe way to configure the style generation process, ensuring that all necessary context is passed consistently to the generators.

_lib/domain/service/file\_generator\_service/style\generator/params · high confidence

The macOS application bundle name has been changed from 'onix\_flutter\_bricks.app' to 'Onix Flutter Project Generator.app' across the Xcode scheme configuration. Additionally, the project's Xcode version has been upgraded from 1300 to 1510, and GPU validation mode has been enabled for debugging.

macos/Runner.xcodeproj/xcshareddata · medium confidence

The application introduces new data models to support Swagger parsing and code generation. A new \SwaggerResponse\ class aggregates swagger models, paths, and tags. A \SwaggerTagResponse\ class is added to handle tag data, including a JSON factory constructor. Additionally, a \JsonClassVariable\ entity is introduced to represent class variables with their Dart type, name, and nullability.

lib/data/model/swagger, lib/data/model/swagger/tag, lib/domain/entity · high confidence

The base project template has been updated to match the latest \onix\_flutter\_core\ library standards and support \freezed\ v3. This includes a comprehensive restructure of the application initialization, dependency injection, and architecture layers. Key changes include: a new \app\_initialization.dart\ for bootstrapping the app and DI; a reorganized \di/\ folder with separate registration files for local, remote, repository, and use-case dependencies; an updated \app.gen.dart\ that integrates theme switching, localization, and optional Sentry/GoRouter support; and the addition of a GraphQL client architecture (\graph\_ql/\) with request processors. Additionally, logging has been refactored into a modular \logger/\ package with a new \LoggerFactory\ and specialized outputs for console, Crashlytics, and Dio, while the router structure now supports both \auto\_route\ and \go\_router\ implementations with reusable flow patterns.

_bricks/flutter\_basic\base/\\brick\\_/{{project\name.snakeCase()}} · high confidence

The Swagger model parsing logic has been refactored to handle different API versions (v2, v3, and unsupported) through a new \BaseSwaggerModelResponse\ interface. This change introduces version-specific implementations (\SwaggerModelResponseV2\, \SwaggerModelResponseV3\) that correctly parse their respective JSON structures, including handling \allOf\ cross-references in v3. Users will see improved accuracy in how Swagger definitions are converted into internal data models, particularly for complex schemas involving inheritance and enums.

lib/data/model/swagger/model · high confidence

The Swagger path response parsing has been refactored to handle Swagger v2 and v3 specifications separately. A new \BaseSwaggerPathResponse\ abstract class routes parsing to version-specific implementations (\SwaggerPathResponseV2\ and \SwaggerPathResponseV3\), enabling distinct handling of input parameters, output responses, and schema structures for each version.

lib/data/model/swagger/path · medium confidence

The Swagger parser now uses a factory pattern to route variable parsing to version-specific implementations (V2, V3, Default, and Unsupported). This change improves the accuracy of type mapping for Swagger 2 and 3 specifications, ensuring that enum lists, 'allOf' schemas, and reference types are correctly interpreted for code generation.

_lib/data/model/swagger/model\variable · medium confidence

The generated Flutter project now includes a new \app.gen.dart\ file that centralizes the \App\ widget, conditionally wrapping it with \GlobalLoaderOverlay\ for non-web platforms and \ScreenUtilInit\ when screen utilities are enabled. The \main.gen.dart\ file has been updated to handle platform initialization, including locking device orientation, initializing Sentry if enabled, and wrapping the app in either a \ProviderScope\ (for Riverpod) or \Bloc\ observers. Additionally, a \RouterLoggingObserver\ has been added to log navigation events for the auto\_route-based router.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib · medium confidence

The application's entry point (main.dart) has been refactored to use a new AppInitialization service for startup logic, replacing the previous direct initialization. The window manager configuration has been updated to hide the title bar and adjust default dimensions. Additionally, the root widget has been migrated from a Cupertino-based app to a Material-based app, and error handling has been improved with a zone guard.

lib · high confidence

The \LabeledSegmentedControl\ and \TextFieldWithLabel\ widgets have been removed from the presentation layer. These components previously provided styled input controls with labels, and their removal indicates a shift away from these specific UI elements in the application's interface.

lib/presentation/widgets · high confidence

The legacy splash screen component, which previously displayed a logo and a button to select a project folder, has been removed from the codebase. This change eliminates the old navigation flow that used to redirect users to the main application page upon folder selection.

_lib/presentation/screens/splash\screen · high confidence

The SessionService now supports two state-management approaches depending on the project configuration. When GoRouter is enabled, the service extends ChangeNotifier and uses notifyListeners() to broadcast state changes. When GoRouter is not used, the service exposes a StreamController that emits SessionStatus updates via a sessionObserver stream. This allows consumers to react to session changes either through the standard Flutter notification pattern or via reactive streams, depending on the project's routing setup.

_bricks/flutter\_clean\base/\\brick\\_/{{project\_name.snakeCase()}}/lib/app/service/session\service · high confidence

The documentation generation process now detects when a project modification is in progress and skips the generation step, outputting an informational message instead. This prevents unnecessary processing and potential conflicts when the project structure is being altered.

_lib/domain/usecase/docs\generation · high confidence

The macOS application now enables the Impeller rendering engine, updates the app name to 'Onix Flutter Project Generator', and sets the app category to productivity. Additionally, the app's security entitlements have been modified: the app-sandbox restriction is disabled for both debug and release builds, and permissions for user-selected file read/write access are granted. The release build also gains permissions for JIT execution and network server access.

macos/Runner · high confidence

The macOS application's display name has been changed from 'onix\_flutter\_bricks' to 'Onix Flutter Project Generator', and the bundle identifier has been updated from 'com.example.onixFlutterBricks' to 'com.onix.flutterprojectgen' to reflect the new product identity.

macos/Runner/Configs · high confidence

The macOS build system has been updated with new build request configurations and an updated target dependency graph. The build request now explicitly configures targets including FlutterMacOS, Pods-Runner, file\_selector\_macos, screen\_retriever, and window\_manager, ensuring they are built in Release configuration. The dependency graph clarifies that these plugins depend on FlutterMacOS, while the Pods-Runner target aggregates all other plugins, streamlining the build process for the macOS platform.

macos/build · high confidence

The app router template now provides two distinct routing implementations: a new GoRouter-based router (app\_router.dart) that initializes the router via a singleton pattern and integrates with Sentry for navigation tracking, and an updated AutoRoute-based router (router\_module.dart) that configures global guards and logging observers. This change allows projects to choose between the modern GoRouter API or the declarative AutoRoute approach, with the template automatically generating the appropriate code based on the isGoRouter flag.

_bricks/flutter\_clean\base/\\brick\\_/{{project\name.snakeCase()}}/lib/app/router · medium confidence

The macOS application has been renamed from 'onix\_flutter\_bricks' to 'Onix Flutter Project Generator', with the bundle identifier updated to 'com.onix.flutterprojectgen'. Additionally, the Xcode project file was upgraded to object version 54, the minimum supported macOS version was raised from 10.11 to 11.0, and the project's last upgrade check was updated to 1510.

macos/Runner.xcodeproj · medium confidence

A fix in assets/rive — 1 commit (1 fix), 1 file.

assets/rive · low confidence · unverified

Added empty test file for the app; Removal of default Flutter counter widget test.

The project has upgraded its Dart SDK constraint to '\>=3.2.0 \<4.0.0' and updated numerous dependencies in pubspec.yaml, including flutter\_svg, window\_manager, logger, get\_it, and flutter\_bloc. The macOS configuration has been updated to target OS X 10.14 with a deployment target of 10.15, and new CocoaPods dependencies for macOS (connectivity\_plus, file\_selector\_macos, flutter\_secure\_storage\_macos, package\_info\_plus, path\_provider\_foundation, shared\_preferences\_foundation, and url\_launcher\_macos) have been added to the Podfile.lock.

(dependencies) · high confidence

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

• CAI 50 → 57 (+7.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 86 (-14.0)
• Architecture 99 → 91 (-8.1)
• Maturity 63 → 68 (+5.4)
• Readiness 26 → 33 (+7.4)
• Security 93 → 95 (+1.7)
• Domain Modelling 61 → 83 (+22.4)

• Change coupling: bloc.dart ↔ source_item_section.dart (lib/core/di/bloc.dart)
• Change coupling: data_components_content.dart ↔ requests_section.dart (lib/presentation/screen/data_components_screen_v2/widget/data_components_content.dart)
• Change coupling: data_components_screen_v2_bloc.dart ↔ requests_section.dart (lib/presentation/screen/data_components_screen_v2/bloc/data_components_screen_v2_bloc.dart)
• Change coupling: data_components_screen_v2_bloc.dart ↔ source_item_section.dart (lib/presentation/screen/data_components_screen_v2/bloc/data_components_screen_v2_bloc.dart)
• Change coupling: request_item.dart ↔ source_item_section.dart (lib/presentation/screen/data_components_screen_v2/widget/sources/request_item.dart)
• Change coupling: swagger_repository_impl.dart ↔ create_swagger_components_usecase.dart (lib/data/repository/swagger_repository_impl.dart)
• Change coupling: swagger_repository_impl.dart ↔ source_item_section.dart (lib/data/repository/swagger_repository_impl.dart)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• LLM evaluation failed
• No exposed public API
• Off-boarding risk: anonymized user #1
• Test reliability not included
• complexity unreadable for .dart, .swift — churn × complexity hotspots could not be measured

• Change coupling: bloc.dart ↔ swagger_repository.dart (lib/core/di/bloc.dart)
• Change coupling: data_components_content.dart ↔ request_item.dart (lib/presentation/screen/data_components_screen_v2/widget/data_components_content.dart)
• Change coupling: procedure_selection_screen.dart ↔ splash_screen.dart (lib/presentation/screen/procedure_selection_screen/procedure_selection_screen.dart)
• Change coupling: project_name_screen.dart ↔ splash_screen.dart (lib/presentation/screen/project_name_screen/project_name_screen.dart)
• Change coupling: swagger_model_response_v3.dart ↔ swagger_path_response_v3.dart (lib/data/model/swagger/model/swagger_model_response_v3.dart)
• Change coupling: swagger_path_response_v3.dart ↔ swagger_remote_source_impl.dart (lib/data/model/swagger/path/swagger_path_response_v3.dart)
• Change coupling: usecase.dart ↔ swagger_repository_impl.dart (lib/core/di/usecase.dart)
• Change-coupling hub: source_item_section.dart → bloc.dart, swagger_repository_impl.dart, data_components_screen_v2_bloc.dart, add_request_dialog_cubit.dart, request_item.dart (lib/presentation/screen/data_components_screen_v2/widget/sources/source_item_section.dart)
• ClassTooLong: SwaggerRepositoryImpl (lib/data/repository/swagger_repository_impl.dart)
• ComponentDialogCubit.addDataObject (cognitive 17) (lib/presentation/screen/data_components_screen_v2/widget/dialogs/add_edit_component_dialog/bloc/component_dialog_cubit.dart)
• ComponentGeneratorService._createRequestEnums (cognitive 19) (lib/domain/service/component_generator/component_generator_service.dart)
• DataComponentsScreenV2Bloc.getSourceObjects (cognitive 18) (lib/presentation/screen/data_components_screen_v2/bloc/data_components_screen_v2_bloc.dart)
• DataObjectComponent._getImports (cognitive 19) (lib/domain/entity/component/data_object_component.dart)
• DataObjectComponent._getMapperObjectVariablesContent (cognitive 50) (lib/domain/entity/component/data_object_component.dart)
• DataObjectComponent._getMapperObjectVariablesContent (cyclomatic 22) (lib/domain/entity/component/data_object_component.dart)
• DataObjectComponent.getMapperBody (cognitive 17) (lib/domain/entity/component/data_object_component.dart)
• DocsService._replaceFileContent (cognitive 19) (lib/domain/service/docs_service/docs_service.dart)
• Documentation: no installation or build instructions (README.md)
• Documentation: written for insiders (docs/how_to/NETWORKING_HOW_TO.md)
• Duplicated block (10 lines × 2) (bricks/flutter_basic_base/brick/{{project_name.snakeCase()}}/lib/app/service/app_service.dart)
• …and 241 more

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

Onix-Systems/onix-flutter-project-generator 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.