Add support to reset lazy singleton instance

lib/get_it.dart

@@ -155,6 +155,58 @@ class GetIt {
     _factoriesByName.clear();
   }
 
+  /// Clears the instance of a lazy singleton registered type, being able to call the factory function on the first call of [get] on that type.
+  void resetLazySingleton<T>({Object instance,
+      String instanceName,
+      void Function(T) disposingFunction}) {
+    if (instance != null) {
+      var registeredInstance = _factories.values
+          .followedBy(_factoriesByName.values)
+          .where((x) => identical(x.instance, instance));
+
+      throwIf(
+        registeredInstance.isEmpty,
+        ArgumentError.value(instance,
+            'There is no object type ${instance.runtimeType} registered in GetIt'),
+      );
+
+      throwIf(
+        registeredInstance.first.factoryType != _ServiceFactoryType.lazy,
+        ArgumentError.value(instance,
+            'There is no type ${instance.runtimeType} registered as LazySingleton in GetIt'),
+      );
+
+      var _factory = registeredInstance.first;
+      disposingFunction?.call(_factory.instance);
+      _factory.instance = null;
+    } else {
+      throwIfNot(
+        !(((const Object() is! T) && instanceName != null)),
+        ArgumentError(
+            'GetIt: You have to provide either a type OR a name not both.'),
+      );
+      throwIfNot(
+        (instanceName != null && _factoriesByName.containsKey(instanceName)) ||
+            _factories.containsKey(T),
+        ArgumentError(
+            'No Type registered ${T.toString()} or instance Name must not be null'),
+      );
+      throwIfNot(
+        (instanceName != null && _factoriesByName.containsKey(instanceName) && _factoriesByName[instanceName].factoryType == _ServiceFactoryType.lazy) ||
+            (_factories.containsKey(T)  && _factories[T].factoryType == _ServiceFactoryType.lazy),
+        ArgumentError.value(instance,
+            'There is no type ${T.toString()} registered as LazySingleton in GetIt'),
+      );
+      if (instanceName == null) {
+        disposingFunction?.call(get<T>());
+        _factories[T]?.instance = null;
+      } else {
+        disposingFunction?.call(get(instanceName));
+        _factoriesByName[T]?.instance = null;
+      }
+    }
+  }
+
   void _register<T>(
       {@required _ServiceFactoryType type,
       FactoryFunc factoryFunc,

test/get_it_test.dart

@@ -203,6 +203,37 @@ void main() {
     GetIt.I.reset();
   });
 
+  test('reset lazySingleton', () {
+    var getIt = GetIt.instance;
+    constructorCounter = 0;
+    getIt.registerLazySingleton<TestBaseClass>(() => TestClass());
+
+    expect(constructorCounter, 0);
+
+    var instance1 = getIt.get<TestBaseClass>();
+
+    expect(instance1 is TestClass, true);
+    expect(constructorCounter, 1);
+
+    var instance2 = getIt.get<TestBaseClass>();
+
+    expect(instance1, instance2);
+
+    expect(constructorCounter, 1);
+
+    GetIt.I.resetLazySingleton<TestBaseClass>();
+
+    var instance3 = getIt.get<TestBaseClass>();
+
+    expect(instance3 is TestClass, true);
+
+    expect(instance1, isNot(instance3));
+
+    expect(constructorCounter, 2);
+
+    GetIt.I.reset();
+  });
+
   test('unregister by instance', () {
     var getIt = GetIt.instance;
     disposeCounter = 0;