Introduction

Velix is Dart/Flutter library implementing some of the core parts required in every Flutter application:

• type meta data
• specification and validation of type constraints
• general purpose mapping framework
• json mapper
• model-based two-way form data-binding
• i18n
• dependency injection container
• command pattern for ui actions

Check out some articles on Medium:

• General purpose mapper
• Commands
• Model driven Forms

Detailed information can be found in the corresponding Wiki.

Dependency Injection

This package contains the dependency injection container, that takes care of the assembly and lifecycle of managed objects. It utilizes the type code-generator of the core package.

Example:

// a module defines the set of managed objects according to their library location
// it can import other modules!
@Module(imports: [])
class TestModule {
  @Create()
  ConfigurationManager createConfigurationManager() {
    return ConfigurationManager();
  }

  // factory method
  @Create()
  ConfigurationValues createConfigurationValues() {
    // will register with the configuration manager via a lifecycle method!
    return ConfigurationValues({
      "foo": 4711
    });
  }
}

// singleton is the default, btw.
@Injectable(scope: "singleton", eager: false)
class Bar {
  const Bar();
}

// environment means that it is a singleton per environment
@Injectable(scope: "environment")
class Foo {
  // instance data

  final Bar bar;
  
  // constructor injection

  const Foo({required this.bar});
}

@Injectable()
class Factory {
  const Factory();
  
  // some lifecycle callbacks

  // injection of the surrounding environment
  @OnInit()
  void onInit(Environment environment) {
    ...
  }

  @OnDestroy()
  void onDestroy() {
    ...
  }
  
  // config value injection!

  @Inject()
  void setFoo(Foo foo, @Value("foo", defaultValue: 1) int value) {
    ...
  }

  // another method based factory
  @Create() 
  Baz createBaz(Bar bar) {
    return Baz();
  }
}

var environment = Environment(forModule: TestModule);
var foo = environment.get<Foo>();

var inherited = Environment(parent: environment);
var inheritedFoo = environment.get<Foo>(); // will be another instance, since it has the scope "environment"

Features are:

• constructor and setter injection
• injection of configuration variables
• possibility to define custom injections
• post processors
• support for factory methods
• support for eager and lazy construction
• support for scopes "singleton", "request" and "environment"
• possibility to add custom scopes
• conditional registration of classes and factories ( aka profiles in spring )
• lifecycle events methods @OnInit, @OnDestroy, @OnRunning
• Automatic discovery and bundling of injectable objects based on their module location, including support for recursive imports
• Instantiation of one or possible more isolated container instances — called environments — each managing the lifecycle of a related set of objects,
• Support for hierarchical environments, enabling structured scoping and layered object management.

Installation

The library is published on pub.flutter-io.cn