CherryPick

https://pub.dev/packages/cherrypick
Admin
CherryPick is a flexible and lightweight dependency injection library for Dart and Flutter that...
Tokens:18,893
Snippets:301
Trust Score:9.9
Update:5 months ago
Show doc for...
Tokens:
Raw
### Dart Example with Cherrypick Annotations

Source: https://pub.dev/packages/cherrypick_annotations/example

Demonstrates setting up an injectable class, a DI module, and example implementations. Requires running `build_runner build` for code generation. Use `package:cherrypick/cherrypick.dart` in real projects.

```dart
// ignore: dangling_library_doc_comments
/// Example using cherrypick_annotations together with cherrypick (core) and cherrypick_generator.

///
/// Steps to use this example:
/// 1. Make sure your example/pubspec.yaml contains:
///     - cherrypick_annotations (this package)
///     - cherrypick (core DI engine)
///     - cherrypick_generator (as a dev_dependency)
///     - build_runner (as a dev_dependency)
/// 2. Run code generation to produce DI injectors and mixins:
///    ```sh
///    dart run build_runner build
///    ```
/// 3. The `_$ApiScreen` mixin will be generated automatically.
/// 4. In your app/bootstrap code, install modules and use the generated features.
///
/// See documentation and advanced details at:
/// https://pub.dev/packages/cherrypick_annotations

import 'package:cherrypick_annotations/cherrypick_annotations.dart';
// In a real project, use this import:
// import 'package:cherrypick/cherrypick.dart';

// Temporary stub for demonstration purposes only.
// In real usage, import 'Module' from `package:cherrypick/cherrypick.dart`.
class Module {}

/// This mixin is a stub for documentation and IDE hints only.
/// In a real project, it will be generated by cherrypick_generator after running build_runner.
///
/// Do not implement or edit this by hand!
mixin _$ApiScreen {}

/// Example UI/service class with dependencies to be injected.
///
/// The [@injectable] annotation tells the generator to create an injector mixin for this class.
/// Fields marked with [@inject] will be automatically filled by the code generator (using DI).
@injectable()
class ApiScreen with _$ApiScreen {
  /// The default (main) implementation of the API service.
  @inject()
  late final ApiService apiService;

  /// An alternate API (mock) implementation, injected by name using @named.
  @inject()
  @named('mock')
  late final ApiService mockApiService;

  /// Logger injected from another scope (e.g., global singleton).
  @inject()
  @scope('global')
  late final Logger logger;
}

/// Example DI module using CherryPick annotations.
///
/// The [@module] annotation tells the generator to treat this class as a source of bindings.
/// Methods annotated with [@singleton], [@named], [@provide], [@instance] will be registered into the DI container.
@module()
abstract class AppModule extends Module {
  /// Global singleton logger available throughout the app.
  @singleton()
  Logger provideLogger() => Logger();

  /// Main API implementation, identified with the name 'main'.
  @named('main')
  ApiService createApi() => ApiService();

  /// Mock API implementation, identified as 'mock'.
  @named('mock')
  ApiService createMockApi() => MockApiService();

  /// UserManager is created with runtime parameters, such as per-user session.
  @provide()
  UserManager createManager(@params() Map<String, dynamic> runtimeParams) {
    return UserManager(runtimeParams['id'] as String);
  }
}

// ---------------------------------------------------------------------------
// Example implementations for demonstration only.
// In a real project, these would contain application/service logic.

/// The main API service.
class ApiService {}

/// A mock API implementation (for development or testing).
class MockApiService extends ApiService {}

/// Manages user operations, created using dynamic (runtime) parameters.
class UserManager {
  final String id;
  UserManager(this.id);
}

/// Global logger service.
class Logger {}

void main() {
  // After running code generation, injectors and mixins will be ready to use.
  // Example integration (pseudo-code):
  //
  // import 'package:cherrypick/cherrypick.dart';
  //
  // final scope = CherryPick.openRootScope()..installModules([$AppModule()]);
  // final screen = ApiScreen()..injectFields();
  // print(screen.apiService); // <-- injected! 
  //
  // This main() is provided for reference only.
}

```

--------------------------------

### Example pubspec.yaml Entry

Source: https://pub.dev/packages/cherrypick/install

This is how the cherrypick dependency will appear in your pubspec.yaml file after installation.

```yaml
dependencies:
  cherrypick: ^3.0.2
```

--------------------------------

### Complete CherryPick Example Application

Source: https://pub.dev/packages/cherrypick

This is a full example of a Dart application using CherryPick for dependency injection. It demonstrates module installation, scope management, asynchronous provider resolution, and named dependency injection. Ensure all services are properly disposed of, even if they don't currently implement `Disposable`, by using `await` with scope closing functions.

```dart
import 'dart:async';
import 'package:meta/meta.dart';
import 'package:cherrypick/cherrypick.dart';

class AppModule extends Module {
  @override
  void builder(Scope currentScope) {
    bind<ApiClient>().withName("apiClientMock").toInstance(ApiClientMock());
    bind<ApiClient>().withName("apiClientImpl").toInstance(ApiClientImpl());
  }
}

class FeatureModule extends Module {
  final bool isMock;
  FeatureModule({required this.isMock});
  @override
  void builder(Scope currentScope) {
    // Async provider for DataRepository with named dependency selection
    bind<DataRepository>()
        .withName("networkRepo")
        .toProvideAsync(() async {
          final client = await Future.delayed(
            Duration(milliseconds: 100),
            () => currentScope.resolve<ApiClient>(
              named: isMock ? "apiClientMock" : "apiClientImpl",
            ),
          );
          return NetworkDataRepository(client);
        })
        .singleton();

    // Chained async provider for DataBloc
    bind<DataBloc>().toProvideAsync(
      () async {
        final repo = await currentScope.resolveAsync<DataRepository>(
            named: "networkRepo");
        return DataBloc(repo);
      },
    );
  }
}

void main() async {
  final scope = CherryPick.openRootScope().installModules([AppModule()]);
  final featureScope = scope.openSubScope("featureScope")
    ..installModules([FeatureModule(isMock: true)]);

  final dataBloc = await featureScope.resolveAsync<DataBloc>();
  dataBloc.data.listen(
    (d) => print('Received data: $d'),
    onError: (e) => print('Error: $e'),
    onDone: () => print('DONE'),
  );

  await dataBloc.fetchData();
}

class DataBloc {
  final DataRepository _dataRepository;
  Stream<String> get data => _dataController.stream;
  final StreamController<String> _dataController = StreamController.broadcast();

  DataBloc(this._dataRepository);

  Future<void> fetchData() async {
    try {
      _dataController.sink.add(await _dataRepository.getData());
    } catch (e) {
      _dataController.sink.addError(e);
    }
  }

  void dispose() {
    _dataController.close();
  }
}

abstract class DataRepository {
  Future<String> getData();
}

class NetworkDataRepository implements DataRepository {
  final ApiClient _apiClient;
  final _token = 'token';
  NetworkDataRepository(this._apiClient);

  @override
  Future<String> getData() async =>
      await _apiClient.sendRequest(
        url: 'www.google.com',
        token: _token,
        requestBody: {'type': 'data'},
      );
}

abstract class ApiClient {
  Future sendRequest({@required String? url, String? token, Map? requestBody});
}

class ApiClientMock implements ApiClient {
  @override
  Future sendRequest(
      {@required String? url, String? token, Map? requestBody}) async {
    return 'Local Data';
  }
}

class ApiClientImpl implements ApiClient {
  @override
  Future sendRequest(
      {@required String? url, String? token, Map? requestBody}) async {
    return 'Network data';
  }
}

```

--------------------------------

### Install Dependencies with Dart Pub Get

Source: https://pub.dev/packages/cherrypick

After adding cherrypick to pubspec.yaml, run this command to install the package.

```bash
dart pub get

```

--------------------------------

### Add Disposable Interface Example

Source: https://pub.dev/packages/cherrypick/changelog

Demonstrates how to implement and use the Disposable interface for automatic resource management in DI. Includes synchronous and asynchronous examples.

```dart
class MyDisposable implements Disposable {
  @override
  Future<void> dispose() async {
    // cleanup resources
  }
}
```

```dart
class MySyncDisposable implements Disposable {
  @override
  void dispose() {
    // cleanup resources
  }
}
```

```dart
final container = CherryPick.createContainer();
container.registerSingleton<MyDisposable>(() => MyDisposable());

// ... later, when the scope is disposed
await container.dispose();
```

--------------------------------

### Basic CherryPick Scope Operations

Source: https://pub.dev/packages/cherrypick

Demonstrates opening a root scope, installing modules, resolving dependencies synchronously and asynchronously, and closing the scope to release resources.

```dart
// Open the main/root scope
final rootScope = CherryPick.openRootScope();

// Install a custom module
rootScope.installModules([AppModule()]);

// Resolve a dependency synchronously
final str = rootScope.resolve<String>();

// Resolve a dependency asynchronously
final result = await rootScope.resolveAsync<String>();

// Recommended: Close the root scope and release all resources
await CherryPick.closeRootScope();

// Alternatively, you may manually call dispose on any scope you manage individually
// await rootScope.dispose();

```

--------------------------------

### Basic Dependency Injection Setup with Cherrypick

Source: https://pub.dev/packages/cherrypick/example

Demonstrates setting up modules, binding instances and providing dependencies using Cherrypick's Scope and Module system. Use this for initializing your application's DI container.

```dart
import 'dart:async';
import 'package:meta/meta.dart';
import 'package:cherrypick/scope.dart';
import 'package:cherrypick/module.dart';

class AppModule extends Module {
  @override
  void builder(Scope currentScope) {
    bind<ApiClient>().withName("apiClientMock").toInstance(ApiClientMock());
    bind<ApiClient>().withName("apiClientImpl").toInstance(ApiClientImpl());
  }
}

class FeatureModule extends Module {
  bool isMock;

  FeatureModule({required this.isMock});

  @override
  void builder(Scope currentScope) {
    bind<DataRepository>()
        .withName("networkRepo")
        .toProvide(
          () => NetworkDataRepository(
            currentScope.resolve<ApiClient>(
              named: isMock ? "apiClientMock" : "apiClientImpl",
            ),
          ),
        )
        .singleton();
    bind<DataBloc>().toProvide(
      () => DataBloc(
        currentScope.resolve<DataRepository>(named: "networkRepo"),
      ),
    );
  }
}

void main() async {
  final scope = openRootScope().installModules([
    AppModule(),
  ]);

  final subScope = scope
      .openSubScope("featureScope")
      .installModules([FeatureModule(isMock: true)]);

  final dataBloc = subScope.resolve<DataBloc>();
  dataBloc.data.listen((d) => print('Received data: $d'),
      onError: (e) => print('Error: $e'), onDone: () => print('DONE'));

  await dataBloc.fetchData();
}

class DataBloc {
  final DataRepository _dataRepository;

  Stream<String> get data => _dataController.stream;
  StreamController<String> _dataController = new StreamController.broadcast();

  DataBloc(this._dataRepository);

  Future<void> fetchData() async {
    try {
      _dataController.sink.add(await _dataRepository.getData());
    } catch (e) {
      _dataController.sink.addError(e);
    }
  }

  void dispose() {
    _dataController.close();
  }
}

abstract class DataRepository {
  Future<String> getData();
}

class NetworkDataRepository implements DataRepository {
  final ApiClient _apiClient;
  final _token = 'token';

  NetworkDataRepository(this._apiClient);

  @override
  Future<String> getData() async => await _apiClient.sendRequest(
      url: 'www.google.com', token: _token, requestBody: {'type': 'data'});
}

abstract class ApiClient {
  Future sendRequest({@required String url, String token, Map requestBody});
}

class ApiClientMock implements ApiClient {
  @override
  Future sendRequest(
      {@required String? url, String? token, Map? requestBody}) async {
    return 'Local Data';
  }
}

class ApiClientImpl implements ApiClient {
  @override
  Future sendRequest(
      {@required String? url, String? token, Map? requestBody}) async {
    return 'Network data';
  }
}

```

--------------------------------

### Register and Resolve Dependencies with Cherrypick

Source: https://pub.dev/packages/cherrypick

A minimal example demonstrating how to register dependencies using a Module and resolve them from the root scope. Ensure to close the scope when done.

```dart
import 'package:cherrypick/cherrypick.dart';

class AppModule extends Module {
  @override
  void builder(Scope currentScope) {
    bind<ApiClient>().toInstance(ApiClientMock());
    bind<String>().toProvide(() => "Hello, CherryPick!");
  }
}

final rootScope = CherryPick.openRootScope();
rootScope.installModules([AppModule()]);

final greeting = rootScope.resolve<String>();
print(greeting); // prints: Hello, CherryPick!

await CherryPick.closeRootScope();

```

--------------------------------

### Add cherrypick_annotations to pubspec.yaml

Source: https://pub.dev/packages/cherrypick_annotations/install

This is an example of how the cherrypick_annotations package will be listed in your pubspec.yaml file after running the add command.

```yaml
dependencies:
  cherrypick_annotations: ^3.0.2
```

--------------------------------

### Extensible Logging API Example

Source: https://pub.dev/packages/cherrypick/changelog

Illustrates how to integrate with the extensible logging API for enhanced DI state and action logging. Shows basic Talker integration.

```dart
import 'package:talker_flutter/talker_flutter.dart';

final talker = Talker();

final container = CherryPick.createContainer(observers: [
  TalkerObserver(talker: talker),
]);
```

--------------------------------

### CherryPick Dependency Binding Examples

Source: https://pub.dev/packages/cherrypick

Demonstrates various ways to bind dependencies in CherryPick, including direct instances, async instances, lazy factories, and parameterized providers. Also shows how to name instances and mark them as singletons.

```dart
void builder(Scope scope) {
  // Provide a direct instance
  bind<String>().toInstance("Hello world");

  // Provide an async direct instance
  bind<String>().toInstanceAsync(Future.value("Hello world"));

  // Provide a lazy sync instance using a factory
  bind<String>().toProvide(() => "Hello world");

  // Provide a lazy async instance using a factory
  bind<String>().toProvideAsync(() async => "Hello async world");

  // Provide an instance with dynamic parameters (sync)
  bind<String>().toProvideWithParams((params) => "Hello $params");

  // Provide an instance with dynamic parameters (async)
  bind<String>().toProvideAsyncWithParams((params) async => "Hello $params");

  // Named instance for retrieval by name
  bind<String>().toProvide(() => "Hello world").withName("my_string");

  // Mark as singleton (only one instance within the scope)
  bind<String>().toProvide(() => "Hello world").singleton();
}
```

--------------------------------

### Add cherrypick_generator to pubspec.yaml

Source: https://pub.dev/packages/cherrypick_generator/install

This is an example of how the cherrypick_generator dependency will appear in your pubspec.yaml file after running the add command. Your editor might automatically run 'dart pub get'.

```yaml
dependencies:
  cherrypick_generator: ^3.0.2
```

--------------------------------

### Register Modules and Auto-Injection

Source: https://pub.dev/packages/cherrypick

Open a root scope, install your application modules, and then use auto-injection for your classes. Call injectFields() on an instance to resolve and set its dependencies.

```dart
final scope = CherryPick.openRootScope()
  ..installModules([$AppModule()]);

final profile = ProfilePage();
profile.injectFields(); // injects all @inject fields

```

--------------------------------

### Example Usage of CherryPickProvider in MyApp

Source: https://pub.dev/packages/cherrypick_flutter

Illustrates how to implement and utilize CherryPickProvider within a Flutter application's root widget. It resolves dependencies using the root scope for routing.

```dart
class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    final rootScope = CherryPickProvider.of(context).openRootScope();

    return MaterialApp.router(
      routerDelegate: rootScope.resolve<AppRouter>().delegate(),
      routeInformationParser:
          rootScope.resolve<AppRouter>().defaultRouteParser(),
    );
  }
}

```

--------------------------------

### Module and Provider Setup

Source: https://pub.dev/packages/cherrypick

Define DI modules by marking classes with @module() and creating provider methods. Use annotations like @singleton, @named, @provide, and @params to control dependency lifecycle, naming, and parameters. The generator produces a class like $AppModule for DI bindings.

```dart
@module()
abstract class AppModule {
  @singleton
  AuthService provideAuth(Api api) => AuthService(api);

  @named('logging')
  @provide
  Future<Logger> provideLogger(@params Map<String, dynamic> args) async => ...;
}
```

--------------------------------

### Example of Circular Dependency

Source: https://pub.dev/packages/cherrypick

Demonstrates a scenario where mutually dependent services are declared, leading to a CircularDependencyException upon resolution.

```dart
class A { A(B b); }
class B { B(A a); }

scope.installModules([
  Module((bind) {
    bind<A>().to((s) => A(s.resolve<B>()));
    bind<B>().to((s) => B(s.resolve<A>()));
  }),
]);

scope.resolve<A>(); // Throws CircularDependencyException
```

--------------------------------

### Hierarchical Subscopes Example

Source: https://pub.dev/packages/cherrypick

Demonstrates creating nested scopes for modular dependency management. Subscopes inherit from parents and allow for context-specific overrides. Remember to close subscopes when no longer needed.

```dart
final rootScope = CherryPick.openRootScope();
rootScope.installModules([AppModule()]);

// Open a hierarchical subscope for a feature or page
final userFeatureScope = rootScope.openSubScope('userFeature');
userFeatureScope.installModules([UserFeatureModule()]);

// Dependencies defined in UserFeatureModule will take precedence
final userService = userFeatureScope.resolve<UserService>();

// If not found in the subscope, lookup continues in the parent (rootScope)
final sharedService = userFeatureScope.resolve<SharedService>();

// You can nest subscopes
final dialogScope = userFeatureScope.openSubScope('dialog');
dialogScope.installModules([DialogModule()]);
final dialogManager = dialogScope.resolve<DialogManager>();

```

--------------------------------

### Add cherrypick_generator to Dart Project

Source: https://pub.dev/packages/cherrypick_generator/install

Run this command in your terminal to add the cherrypick_generator as a dependency. This command also implicitly runs 'dart pub get'.

```bash
dart pub add cherrypick_generator
```

--------------------------------

### Import Cherrypick in Dart Code

Source: https://pub.dev/packages/cherrypick/install

Import the cherrypick library into your Dart files to start using its features.

```dart
import 'package:cherrypick/cherrypick.dart';
```

--------------------------------

### Provide State with CherryPickProvider

Source: https://pub.dev/packages/cherrypick_flutter

Encapsulate the widget tree section requiring root or sub-scope access with CherryPickProvider. This setup is necessary for dependency injection within Flutter.

```dart
import 'package:flutter/material.dart';
import 'package:cherrypick_flutter/cherrypick_flutter.dart';

void main() {
  runApp(
    CherryPickProvider(
      child: MyApp(),
    ),
  );
}

```

--------------------------------

### Declare cherrypick_flutter Dependency in pubspec.yaml

Source: https://pub.dev/packages/cherrypick_flutter/install

This is an example of how the cherrypick_flutter dependency will appear in your pubspec.yaml file after running `flutter pub add`. Ensure this line is correctly formatted under the 'dependencies' section.

```yaml
dependencies:
  cherrypick_flutter: ^3.0.2
```

--------------------------------

### Implement PrintCherryPickObserver

Source: https://pub.dev/packages/cherrypick

Use the built-in PrintCherryPickObserver for console logs. All DI actions and errors will be printed to the console.

```dart
import 'package:cherrypick/cherrypick.dart';

void main() {
  // Use the built-in PrintCherryPickObserver for console logs
  final observer = PrintCherryPickObserver();
  final scope = CherryPick.openRootScope(observer: observer);
  // All DI actions and errors will now be printed!
}
```

--------------------------------

### Define DI Module and Providers

Source: https://pub.dev/packages/cherrypick_annotations

Use `@module`, `@singleton`, `@named`, `@instance`, and `@provide` annotations to define DI modules and register providers. The `@params` annotation is used for runtime-supplied arguments.

```dart
import 'package:cherrypick_annotations/cherrypick_annotations.dart';

@module()
abstract class AppModule {
  @singleton()
  Dio dio() => Dio();

  @named('baseUrl')
  String baseUrl() => 'https://api.example.com';

  @instance()
  Foo foo() => Foo();

  @provide()
  Bar bar(Foo foo) => Bar(foo);

  @provide()
  String greet(@params() dynamic params) => 'Hello $params';
}

```

```dart
final class $AppModule extends AppModule {
  @override
  void builder(Scope currentScope) {
    bind<Dio>().toProvide(() => dio()).singleton();
    bind<String>().toProvide(() => baseUrl()).withName('baseUrl');
    bind<Foo>().toInstance(foo());
    bind<Bar>().toProvide(() => bar(currentScope.resolve<Foo>()));
    bind<String>().toProvideWithParams((args) => greet(args));
  }
}

```

--------------------------------

### Implement TalkerCherryPickObserver

Source: https://pub.dev/packages/cherrypick

For richer logging, analytics, or UI overlays, use an advanced observer such as talker_cherrypick_logger. All container events go to the Talker log system.

```dart
import 'package:cherrypick/cherrypick.dart';
import 'package:talker/talker.dart';
import 'package:talker_cherrypick_logger/talker_cherrypick_logger.dart';

void main() {
  final talker = Talker();
  final observer = TalkerCherryPickObserver(talker);
  CherryPick.openRootScope(observer: observer);
  // All container events go to the Talker log system!
}
```

--------------------------------

### Provide Dependency with @provide

Source: https://pub.dev/packages/cherrypick_annotations

Use on methods to indicate they provide a dependency to the DI module. Dependencies listed as parameters are resolved and injected.

```dart
@provide()
Bar bar(Foo foo) => Bar(foo);

```

--------------------------------

### Configure pubspec.yaml for Cherrypick

Source: https://pub.dev/packages/cherrypick/example

Add cherrypick as a path dependency in your pubspec.yaml file to use it in your project.

```yaml
name: example
version: 1.0.0

environment:
  sdk: ">=2.12.0 <3.0.0"


dependencies:
  cherrypick:
    path: ../

dev_dependencies:
  test: ^1.16.8


```

--------------------------------

### Dart Type Name Convention Violation

Source: https://pub.dev/packages/cherrypick_annotations/score

This code snippet highlights a violation of Dart's UpperCamelCase identifier convention for type names. Ensure type names follow this convention for better code readability and adherence to Dart style guides.

```dart
final class inject {
             ^^^^^^
           }

```

```dart
final class injectable {
             ^^^^^^^^^^^
           }

```

--------------------------------

### Run Code Generation

Source: https://pub.dev/packages/cherrypick

Execute the build_runner command to generate necessary DI code after annotating your classes and modules. Use --delete-conflicting-outputs to ensure a clean build.

```bash
dart run build_runner build --delete-conflicting-outputs
# or in Flutter:
flutter pub run build_runner build --delete-conflicting-outputs

```

--------------------------------

### Synchronous Disposable Resource Management

Source: https://pub.dev/packages/cherrypick

Shows how to implement the Disposable interface for automatic cleanup of resources like caches when a scope is closed. Ensure to call `CherryPick.closeRootScope()` for disposal.

```dart
class CacheManager implements Disposable {
  void dispose() {
    cache.clear();
    print('CacheManager disposed!');
  }
}

final scope = CherryPick.openRootScope();
scope.installModules([
  Module((bind) => bind<CacheManager>().toProvide(() => CacheManager()).singleton()),
]);

// ...later
await CherryPick.closeRootScope(); // prints: CacheManager disposed!

```

--------------------------------

### Module Registration Annotations

Source: https://pub.dev/packages/cherrypick_generator

Annotate classes with `@module()` to mark them as DI modules. Use annotations like `@provide`, `@instance`, `@singleton`, `@named`, and `@params` on methods and parameters for module-based DI.

```dart
import 'package:cherrypick_annotations/cherrypick_annotations.dart';

@module()
class MyModule {
  @singleton
  @instance
  AuthService provideAuth(Api api);

  @provide
  @named('logging')
  Future<Logger> provideLogger(@params Map<String, dynamic> args);
}
```

--------------------------------

### Run Cherrypick Generator Build

Source: https://pub.dev/packages/cherrypick_generator

Execute the build_runner to generate dependency injection code. Use 'dart run' for Dart projects or 'flutter pub run' for Flutter projects.

```bash
dart run build_runner build

```

```bash
# or, if using Flutter:
flutter pub run build_runner build

```

--------------------------------

### Add cherrypick_flutter to Flutter Project

Source: https://pub.dev/packages/cherrypick_flutter/install

Run this command in your project's root directory to add the cherrypick_flutter package as a dependency. This command automatically updates your pubspec.yaml file and fetches the package.

```bash
 $ flutter pub add cherrypick_flutter
```

--------------------------------

### Provide New Instance with @instance

Source: https://pub.dev/packages/cherrypick_annotations

Use on methods or classes to provide a new instance on each request, rather than a singleton.

```dart
@instance()
Foo foo() => Foo();

```

--------------------------------

### Receive Runtime Arguments with @params

Source: https://pub.dev/packages/cherrypick_annotations

Indicates that this parameter should receive runtime-supplied arguments during dependency resolution.

```dart
@provide()
String greet(@params() dynamic params) => 'Hello $params';

```

--------------------------------

### Apache License 2.0

Source: https://pub.dev/packages/cherrypick_generator

This code snippet represents the license under which the cherrypick generator is distributed.

```text
Licensed under the Apache License, Version 2.0

```

--------------------------------

### Asynchronous Disposable Resource Management

Source: https://pub.dev/packages/cherrypick

Illustrates managing asynchronous cleanup, such as closing a socket, by implementing the `Disposable` interface with an async `dispose()` method. The `CherryPick.closeRootScope()` call will await these asynchronous disposals.

```dart
class MyServiceWithSocket implements Disposable {
  @override
  Future<void> dispose() async {
    await socket.close();
    print('Socket closed!');
  }
}

scope.installModules([
  Module((bind) => bind<MyServiceWithSocket>().toProvide(() => MyServiceWithSocket()).singleton()),
]);

await CherryPick.closeRootScope(); // awaits async disposal

```

--------------------------------

### Add CherryPick to pubspec.yaml

Source: https://pub.dev/packages/cherrypick

Include cherrypick, cherrypick_annotations, cherrypick_generator, and build_runner in your pubspec.yaml file to use CherryPick's dependency injection features.

```yaml
dependencies:
  cherrypick: any
  cherrypick_annotations: any

dev_dependencies:
  cherrypick_generator: any
  build_runner: any

```

--------------------------------

### Use @module Annotation

Source: https://pub.dev/packages/cherrypick_annotations

Mark classes with `@module()` to designate them as DI modules. These modules serve as the central point for registering dependency providers within the CherryPick DI framework.

```dart
@module()
abstract class AppModule {}

```

--------------------------------

### Add Cherrypick to pubspec.yaml

Source: https://pub.dev/packages/cherrypick

Add the cherrypick package to your project's dependencies in pubspec.yaml.

```yaml
dependencies:
  cherrypick: ^<latest_version>

```

--------------------------------

### Singleton Behavior with Parameterized Providers

Source: https://pub.dev/packages/cherrypick

When `.singleton()` is chained after `toProvideWithParams` or `toProvideAsyncWithParams`, only the first `resolve` call with parameters creates a new instance. Subsequent calls, regardless of parameters, return the cached instance.

```dart
bind<Service>().toProvideWithParams((params) => Service(params)).singleton();
final a = scope.resolve<Service>(params: 1); // creates Service(1)
final b = scope.resolve<Service>(params: 2); // returns Service(1)
print(identical(a, b)); // true
```

--------------------------------

### Generated Module Registration

Source: https://pub.dev/packages/cherrypick_generator

This is the simplified output of the generator for module registration. It creates a class that defines how to bind dependencies within a scope.

```dart
final class $MyModule extends MyModule {
  @override
  void builder(Scope currentScope) {
    bind<AuthService>()
      .toInstance(provideAuth(currentScope.resolve<Api>()))
      .singleton();

    bind<Logger>()
      .toProvideAsyncWithParams((args) => provideLogger(args))
      .withName('logging');
  }
}
```

--------------------------------

### Add cherrypick_annotations to Flutter Project

Source: https://pub.dev/packages/cherrypick_annotations/install

Use this command to add the cherrypick_annotations package as a dependency in your Flutter project.

```bash
$ flutter pub add cherrypick_annotations
```

--------------------------------

### Add cherrypick_annotations to Dart Project

Source: https://pub.dev/packages/cherrypick_annotations/install

Use this command to add the cherrypick_annotations package as a dependency in your Dart project.

```bash
$ dart pub add cherrypick_annotations
```

--------------------------------

### Add cherrypick_flutter to pubspec.yaml

Source: https://pub.dev/packages/cherrypick_flutter

Add this dependency to your pubspec.yaml file to include the cherrypick_flutter package in your project.

```yaml
dependencies:
  cherrypick_flutter: ^1.0.0

```

--------------------------------

### Add Cherrypick Dependency with Flutter

Source: https://pub.dev/packages/cherrypick/install

Use this command to add the cherrypick package to your Flutter project's dependencies.

```bash
$ flutter pub add cherrypick
```

--------------------------------

### Add Dependencies for Cherrypick Generator

Source: https://pub.dev/packages/cherrypick_generator

Include cherrypick_annotations in your project dependencies and cherrypick_generator and build_runner in your dev_dependencies. Ensure build_runner version is compatible.

```yaml
dependencies:
  cherrypick_annotations: ^latest

dev_dependencies:
  cherrypick_generator: ^latest
  build_runner: ^2.1.0

```

--------------------------------

### Import cherrypick_flutter in Dart Code

Source: https://pub.dev/packages/cherrypick_flutter/install

Use this import statement at the beginning of your Dart files to access the functionalities provided by the cherrypick_flutter package. This makes the package's classes and functions available for use in your project.

```dart
import 'package:cherrypick_flutter/cherrypick_flutter.dart';
```

--------------------------------

### Enable Local Cycle Detection

Source: https://pub.dev/packages/cherrypick

Enable local cycle detection within a single scope. This is enabled by default when opening a safe root scope.

```dart
final scope = CherryPick.openSafeRootScope(); // Local detection enabled by default
// or, for an existing scope:
scope.enableCycleDetection();
```

--------------------------------

### Experimental openScope Warning

Source: https://pub.dev/packages/cherrypick_flutter/score

This warning indicates that the 'openScope' function is experimental and may be subject to change or removal in future versions. It is located in lib/src/cherrypick_provider.dart at line 68.

```dart
      CherryPick.openScope(scopeName: scopeName, separator: separator);
```

--------------------------------

### Enable Global Cycle Detection

Source: https://pub.dev/packages/cherrypick

Enable global cycle detection across all scopes. This helps prevent infinite loops in complex dependency graphs.

```dart
CherryPick.enableGlobalCrossScopeCycleDetection();
final rootScope = CherryPick.openGlobalSafeRootScope();
```

--------------------------------

### Add Cherrypick Dependency with Dart

Source: https://pub.dev/packages/cherrypick/install

Use this command to add the cherrypick package to your Dart project's dependencies.

```bash
$ dart pub add cherrypick
```

--------------------------------

### Incorrect Dependency Resolution in Module Builder

Source: https://pub.dev/packages/cherrypick

Illustrates incorrect dependency resolution within a module builder when using `toInstance`. Attempting to resolve a dependency that has just been registered can lead to errors because it's not yet available in the scope.

```dart
void builder(Scope scope) {
  bind<A>().toInstance(A());
  // Error! At this point, A is not registered yet.
  bind<B>().toInstance(B(scope.resolve<A>()));
}
```

```dart
void builder(Scope scope) {
  bind<A>().toProvide(() => A());
  // Error! At this point, A is not registered yet.
  bind<B>().toInstance(B(scope.resolve<A>()));
}
```

--------------------------------

### Import cherrypick_generator in Dart Code

Source: https://pub.dev/packages/cherrypick_generator/install

Use this import statement in your Dart files to access the cherrypick_generator library.

```dart
import 'package:cherrypick_generator/cherrypick_generator.dart';
```

--------------------------------

### Access State with CherryPickProvider.of

Source: https://pub.dev/packages/cherrypick_flutter

Access the state provided by CherryPickProvider within widget build methods using the `of` method. This allows opening root and sub-scopes for dependency resolution.

```dart
class MyWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final CherryPickProvider cherryPick = CherryPickProvider.of(context);
    final rootScope = cherryPick.openRootScope();

    // Use the rootScope or open a subScope as needed
    final subScope = cherryPick.openSubScope(scopeName: "exampleScope");

    return Text('Scope accessed!');
  }
}

```

--------------------------------

### Correct Dependency Resolution in Module Builder

Source: https://pub.dev/packages/cherrypick

When using `toInstance` within a module's builder, manually construct the dependency chain before binding. Avoid calling `scope.resolve<T>()` for types registered in the same builder execution, as they may not be available yet.

```dart
void builder(Scope scope) {
  final a = A();
  final b = B(a);
  final c = C(b);
  bind<A>().toInstance(a);
  bind<B>().toInstance(b);
  bind<C>().toInstance(c);
}
```

--------------------------------

### Field Injection with Annotations

Source: https://pub.dev/packages/cherrypick

Use @injectable() on classes and @inject() on fields for automatic dependency injection. After running build_runner, a mixin will be generated for field injection. Call injectFields() to set up dependencies.

```dart
import 'package:cherrypick_annotations/cherrypick_annotations.dart';

@injectable()
class ProfilePage with _$ProfilePage {
  @inject()
  late final AuthService auth;

  @inject()
  @scope('profile')
  late final ProfileManager manager;

  @inject()
  @named('admin')
  late final UserService adminUserService;
}
```

--------------------------------

### Module Definition in CherryPick

Source: https://pub.dev/packages/cherrypick

Defines a `Module` by extending the `Module` class and implementing the `builder` method. This method is used to configure dependency bindings within a specific scope.

```dart
class AppModule extends Module {
  @override
  void builder(Scope currentScope) {
    bind<ApiClient>().toInstance(ApiClientMock());
    bind<String>().toProvide(() => "Hello world!");
  }
}
```

--------------------------------

### Conditional Cycle Detection in Production

Source: https://pub.dev/packages/cherrypick

Conditionally enable global cycle detection based on the build mode. Detection is enabled in debug mode and disabled in production for performance.

```dart
import 'package:flutter/foundation.dart';

void main() {
  if (kDebugMode) {
    CherryPick.enableGlobalCycleDetection();
    CherryPick.enableGlobalCrossScopeCycleDetection();
  }
  runApp(MyApp());
}
```
Tokens:
Raw