A simple, lightweight factory registry for Dart that makes creating instances of registered types easy and flexible.
Perfect for dependency injection, prototyping, configuration management, and testing!
✨ Simple API: Just 5 intuitive methods to learn
🎯 Type-safe: Full generic type support
🪶 Lightweight: Zero dependencies
🔧 Flexible: Register any factory function
🧪 Testable: Easy to clear and reset for testing
Add this to your pubspec.yaml:
dependencies:
instancer: ^1.0.0Then import it:
import 'package:instancer/instancer.dart';import 'package:instancer/instancer.dart';
class User {
final String name;
final int age;
User({required this.name, required this.age});
}
void main() {
// 1️⃣ Register a factory function
Instancer.register<User>(() => User(name: 'Guest', age: 18));
// 2️⃣ Create instances anywhere in your code
final user1 = Instancer.create<User>();
final user2 = Instancer.create<User>();
print(user1.name); // Output: Guest
print(identical(user1, user2)); // Output: false (different instances)
}class AppConfig {
final String apiUrl;
final bool debugMode;
final int timeout;
AppConfig({
required this.apiUrl,
required this.debugMode,
required this.timeout,
});
}
void main() {
// Development environment
Instancer.register<AppConfig>(
() => AppConfig(
apiUrl: 'http://localhost:3000',
debugMode: true,
timeout: 30,
),
);
// Use it anywhere in your app
final config = Instancer.create<AppConfig>();
print(config.apiUrl); // http://localhost:3000
// Switch to production (just re-register)
Instancer.register<AppConfig>(
() => AppConfig(
apiUrl: 'https://api.production.com',
debugMode: false,
timeout: 10,
),
);
final prodConfig = Instancer.create<AppConfig>();
print(prodConfig.apiUrl); // https://api.production.com
}class Database {
void query(String sql) => print('Executing: $sql');
}
class UserRepository {
final Database database;
UserRepository({required this.database});
void save(String name) {
database.query("INSERT INTO users (name) VALUES ('$name')");
}
}
class UserService {
final UserRepository repository;
UserService({required this.repository});
void createUser(String name) {
print('Creating user: $name');
repository.save(name);
}
}
void main() {
// Register dependencies in order
Instancer.register<Database>(() => Database());
Instancer.register<UserRepository>(
() => UserRepository(database: Instancer.create<Database>()),
);
Instancer.register<UserService>(
() => UserService(repository: Instancer.create<UserRepository>()),
);
// Use the service
final userService = Instancer.create<UserService>();
userService.createUser('Alice');
// Output:
// Creating user: Alice
// Executing: INSERT INTO users (name) VALUES ('Alice')
}abstract class ApiClient {
Future<String> fetchData();
}
class RealApiClient implements ApiClient {
@override
Future<String> fetchData() async {
// Real network call
return 'Real data from server';
}
}
class MockApiClient implements ApiClient {
@override
Future<String> fetchData() async {
// Mock data for testing
return 'Mock data';
}
}
void main() {
// Production code
Instancer.register<ApiClient>(() => RealApiClient());
// In your tests, just re-register with mock
Instancer.register<ApiClient>(() => MockApiClient());
final client = Instancer.create<ApiClient>();
client.fetchData().then(print); // Output: Mock data
// Clean up after tests
Instancer.clear();
}class EmailTemplate {
final String subject;
final String body;
final List<String> recipients;
EmailTemplate({
required this.subject,
required this.body,
this.recipients = const [],
});
@override
String toString() => 'Email: $subject to ${recipients.length} recipients';
}
void main() {
// Register a prototype template
Instancer.register<EmailTemplate>(
() => EmailTemplate(
subject: 'Welcome!',
body: 'Welcome to our service',
recipients: ['user@example.com'],
),
);
// Create multiple emails from the same template
final email1 = Instancer.create<EmailTemplate>();
final email2 = Instancer.create<EmailTemplate>();
print(email1); // Email: Welcome! to 1 recipients
print(email2); // Email: Welcome! to 1 recipients
print('Same instance? ${identical(email1, email2)}'); // false
}class Logger {
static int _instanceCount = 0;
final int id;
Logger() : id = ++_instanceCount;
void log(String message) {
print('[Logger $id] $message');
}
}
void main() {
// Each creation increases the counter
Instancer.register<Logger>(() => Logger());
final logger1 = Instancer.create<Logger>();
final logger2 = Instancer.create<Logger>();
final logger3 = Instancer.create<Logger>();
logger1.log('First message'); // [Logger 1] First message
logger2.log('Second message'); // [Logger 2] Second message
logger3.log('Third message'); // [Logger 3] Third message
}Registers a factory function for type T.
Instancer.register<User>(() => User(name: 'John', age: 25));Parameters:
factory: A function that returns a new instance of typeT
Creates a new instance of type T using the registered factory.
final user = Instancer.create<User>();Returns: A new instance of type T
Throws: StateError if no factory is registered for type T
Checks if a factory is registered for type T.
if (Instancer.isRegistered<User>()) {
print('User factory is registered!');
}Returns: true if registered, false otherwise
Removes the factory for type T.
final removed = Instancer.unregister<User>();
print('Factory removed: $removed');Returns: true if a factory was removed, false if none existed
Removes all registered factories. Useful for testing or resetting state.
Instancer.clear();Returns the number of registered factories.
print('Total registered factories: ${Instancer.count}');| Feature | Instancer | Traditional Singleton | Factory Pattern |
|---|---|---|---|
| No inheritance required | ✅ | ❌ | ✅ |
| No code generation | ✅ | ✅ | ✅ |
| Multiple instances | ✅ | ❌ | ✅ |
| Easy to test | ✅ | ❌ | ✅ |
| Dynamic registration | ✅ | ❌ | ❌ |
| Zero dependencies | ✅ | ✅ | ✅ |
- No inheritance required: Your classes don't need to extend anything
- No code generation: Works without
build_runneror code generation - Pure Dart: No platform-specific code, works everywhere (Flutter, CLI, Web)
- Flexible: Register simple constructors or complex initialization logic
- Testable: Easy to swap implementations for mocking in tests
- Simple: Only 5 methods to learn -
register,create,isRegistered,unregister,clear
✅ Dependency Injection - Register and inject dependencies
✅ Configuration Management - Switch between dev/prod configs
✅ Testing - Replace real implementations with mocks
✅ Prototype Pattern - Create multiple instances from templates
✅ Factory Pattern - Centralized instance creation
✅ Plugin Systems - Register and create plugin instances
// In your app initialization
void setupDependencies() {
Instancer.register<Database>(() => SqliteDatabase());
Instancer.register<ApiClient>(() => HttpApiClient());
Instancer.register<AuthService>(() => AuthService());
}
// Use anywhere in your app
final auth = Instancer.create<AuthService>();void setupConfig(Environment env) {
if (env == Environment.dev) {
Instancer.register<Config>(() => DevConfig());
} else {
Instancer.register<Config>(() => ProdConfig());
}
}void main() {
setUp(() {
Instancer.register<Service>(() => MockService());
});
tearDown(() {
Instancer.clear(); // Always clean up!
});
test('service works', () {
final service = Instancer.create<Service>();
// Test...
});
}Contributions are welcome! Please read our CONTRIBUTING.md for details.
- Check existing issues
- Create a new issue or submit a pull request
- Follow the existing code style
MIT License - see the LICENSE file for details.
Created with ❤️ by Uproid
Like this package? Give it a ⭐ on GitHub!
