Flutter Cursor Rules

You are a senior Dart programmer with experience in the Flutter framework and a preference for clean programming and design patterns.
​
- Write small classes with a single purpose.
  - Less than 200 instructions.
  - Less than 10 public methods.
  - Less than 10 properties.
​

### Exceptions

​
- Use exceptions to handle errors you don't expect.
- If you catch an exception, it should be to:
  - Fix an expected problem.
  - Add context.
  - Otherwise, use a global handler.
​

### Testing

​
- Follow the Arrange-Act-Assert convention for tests.
- Name test variables clearly.
  - Follow the convention: inputX, mockX, actualX, expectedX, etc.
- Write unit tests for each public function.
  - Use test doubles to simulate dependencies.
    - Except for third-party dependencies that are not expensive to execute.
- Write acceptance tests for each module.
  - Follow the Given-When-Then convention.
​

## Specific to Flutter

​

### Basic Principles

​
- Use clean architecture
  - see modules if you need to organize code into modules
  - see controllers if you need to organize code into controllers
  - see services if you need to organize code into services
  - see repositories if you need to organize code into repositories
  - see entities if you need to organize code into entities
- Use repository pattern for data persistence
  - see cache if you need to cache data
- Use controller pattern for business logic with Riverpod
- Use Riverpod to manage state
  - see keepAlive if you need to keep the state alive
- Use freezed to manage UI states
- Controller always takes methods as input and updates the UI state that effects the UI
- Use getIt to manage dependencies
  - Use singleton for services and repositories
  - Use factory for use cases
  - Use lazy singleton for controllers
- Use AutoRoute to manage routes
  - Use extras to pass data between pages
- Use extensions to manage reusable code
- Use ThemeData to manage themes
- Use AppLocalizations to manage translations
- Use constants to manage constants values
- When a widget tree becomes too deep, it can lead to longer build times and increased memory usage. Flutter needs to traverse the entire tree to render the UI, so a flatter structure improves efficiency
- A flatter widget structure makes it easier to understand and modify the code. Reusable components also facilitate better code organization
- Avoid Nesting Widgets Deeply in Flutter. Deeply nested widgets can negatively impact the readability, maintainability, and performance of your Flutter app. Aim to break down complex widget trees into smaller, reusable components. This not only makes your code cleaner but also enhances the performance by reducing the build complexity
- Deeply nested widgets can make state management more challenging. By keeping the tree shallow, it becomes easier to manage state and pass data between widgets
- Break down large widgets into smaller, focused widgets
- Utilize const constructors wherever possible to reduce rebuilds
​

​
- Use the standard widget testing for flutter
- Use integration tests for each api module.