V9.2.0: Cache allReady() future for watch_it scope detection

- allReady() now caches its Future and returns the same instance on repeated calls
- Cache is invalidated when new async singletons are registered
- Pending async singletons complete their ready completer when removed via unregister() or scope reset

Author: escamoteur

CHANGELOG.md

@@ -1,3 +1,10 @@
+## [9.2.0] - 2025-12-03
+
+* `allReady()` now caches its Future and returns the same instance on repeated calls
+  * Cache is automatically invalidated when new async singletons are registered
+  * This enables watch_it to detect when async registrations change (e.g., after `pushNewScope`)
+* Fixed: pending async singletons now complete their ready completer when removed via `unregister()` or scope reset, allowing `allReady()` to complete properly
+
 ## [9.1.1] - 2025-11-25
 
 * Updated example project

lib/get_it_impl.dart

@@ -447,6 +447,10 @@ class _Scope {
         ..sort((a, b) => b.registrationNumber.compareTo(a.registrationNumber));
 
       for (final registration in registrations) {
+        // Complete pending completers so allReady() can complete
+        if (!registration.isReady) {
+          registration._readyCompleter.complete();
+        }
         await registration.dispose();
       }
     }
@@ -604,6 +608,9 @@ class _GetItImplementation implements GetIt {
   /// Completer.
   final _globalReadyCompleter = Completer();
 
+  /// Cached allReady future - invalidated when new async singletons are registered
+  Future<void>? _cachedAllReadyFuture;
+
   /// By default it's not allowed to register a type a second time.
   /// If you really need to you can disable the asserts by setting[allowReassignment]= true
   @override
@@ -1430,6 +1437,12 @@ class _GetItImplementation implements GetIt {
       registrationToRemove._referenceCount--;
       return;
     }
+
+    // Complete pending completer so allReady() can complete
+    if (!registrationToRemove.isReady) {
+      registrationToRemove._readyCompleter.complete();
+    }
+
     final typeRegistration = registrationToRemove.registeredIn;
 
     if (registrationToRemove.isNamedRegistration) {
@@ -1659,6 +1672,7 @@ class _GetItImplementation implements GetIt {
     }
     _scopes.removeRange(1, _scopes.length);
     await resetScope(dispose: dispose);
+    _cachedAllReadyFuture = null;
     assert(() {
       _fireDevToolEvent('reset', {'dispose': dispose});
       return true;
@@ -2069,6 +2083,9 @@ class _GetItImplementation implements GetIt {
     // it is dependent on other registered Singletons.
     if ((isAsync || (dependsOn?.isNotEmpty ?? false)) &&
         type == ObjectRegistrationType.constant) {
+      // Invalidate allReady cache since a new async singleton affects allReady()
+      _cachedAllReadyFuture = null;
+
       /// Any client awaiting the completion of this Singleton
       /// Has to wait for the completion of the Singleton itself as well
       /// as for the completion of all the Singletons this one depends on
@@ -2305,6 +2322,17 @@ class _GetItImplementation implements GetIt {
     Duration? timeout,
     bool ignorePendingAsyncCreation = false,
   }) {
+    // Return cached future if available
+    if (_cachedAllReadyFuture != null) {
+      if (timeout != null) {
+        return _cachedAllReadyFuture!.timeout(
+          timeout,
+          onTimeout: () => throw _createTimeoutError(),
+        );
+      }
+      return _cachedAllReadyFuture!;
+    }
+
     final futures = FutureGroup();
     _allRegistrations
         .where(
@@ -2331,14 +2359,16 @@ class _GetItImplementation implements GetIt {
       }
     });
     futures.close();
+
+    _cachedAllReadyFuture = futures.future;
+
     if (timeout != null) {
-      return futures.future.timeout(
+      return _cachedAllReadyFuture!.timeout(
         timeout,
-        onTimeout: () async => throw _createTimeoutError(),
+        onTimeout: () => throw _createTimeoutError(),
       );
-    } else {
-      return futures.future;
     }
+    return _cachedAllReadyFuture!;
   }
 
   /// Returns if all async Singletons are ready without waiting

pubspec.yaml

@@ -1,6 +1,6 @@
 name: get_it
 description: Simple direct Service Locator that allows to decouple the interface from a concrete implementation and  to access the concrete implementation from everywhere in your App"
-version: 9.1.1
+version: 9.2.0
 maintainer: Thomas Burkhart (@escamoteur)
 homepage: https://github.com/flutter-it/get_it
 repository: https://github.com/flutter-it/get_it

test/async_test.dart

@@ -946,6 +946,84 @@ void main() {
       expect(instance.initCompleted, isTrue);
     });
   });
+
+  group('allReady caching', () {
+    test('allReady returns same Future on repeated calls', () async {
+      final getIt = GetIt.instance;
+      await getIt.reset();
+
+      getIt.registerSingletonAsync<TestClass>(
+        () => Future.delayed(const Duration(milliseconds: 10))
+            .then((_) => TestClass(internalCompletion: false)),
+      );
+
+      final future1 = getIt.allReady();
+      final future2 = getIt.allReady();
+
+      expect(identical(future1, future2), isTrue);
+
+      await future1;
+    });
+
+    test('allReady returns new Future after registerSingletonAsync', () async {
+      final getIt = GetIt.instance;
+      await getIt.reset();
+
+      getIt.registerSingletonAsync<TestClass>(
+        () => Future.delayed(const Duration(milliseconds: 10))
+            .then((_) => TestClass(internalCompletion: false)),
+      );
+
+      final future1 = getIt.allReady();
+      await future1;
+
+      // Register another async singleton
+      getIt.registerSingletonAsync<TestClass2>(
+        () => Future.delayed(const Duration(milliseconds: 10))
+            .then((_) => TestClass2(internalCompletion: false)),
+      );
+
+      final future2 = getIt.allReady();
+
+      // Should be a new future since we registered a new async singleton
+      expect(identical(future1, future2), isFalse);
+
+      await future2;
+    });
+
+    test(
+        'allReady returns new Future after pushNewScope with async registration',
+        () async {
+      final getIt = GetIt.instance;
+      await getIt.reset();
+
+      getIt.registerSingletonAsync<TestClass>(
+        () => Future.delayed(const Duration(milliseconds: 10))
+            .then((_) => TestClass(internalCompletion: false)),
+      );
+
+      final future1 = getIt.allReady();
+      await future1;
+
+      // Push a new scope with an async registration
+      getIt.pushNewScope(
+        init: (getIt) {
+          getIt.registerSingletonAsync<TestClass2>(
+            () => Future.delayed(const Duration(milliseconds: 10))
+                .then((_) => TestClass2(internalCompletion: false)),
+          );
+        },
+      );
+
+      final future2 = getIt.allReady();
+
+      // Should be a new future since we registered a new async singleton in the scope
+      expect(identical(future1, future2), isFalse);
+
+      await future2;
+      await getIt.popScope();
+    });
+  });
 }
 
 abstract class Service1 {}