get_it

• Added AI skill files in skills/ directory for AI coding assistants
• Added AI-Assisted Development section to README

• 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

• 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

Remove generated test folder from example

• Updated example project

• Remove gradlew patterns from .gitignore and example/.gitignore to include scripts
• Add gradle-wrapper.jar to .pubignore to exclude binary from package
• Keeps gradle scripts for building example, excludes ~60KB binary
• Fixes pub publish warning about ignored files

• Added DevTools extension for visualizing and inspecting GetIt registrations
  • View all registered objects with their type, scope, registration mode, and state
  • See instance details via toString() output for created instances
  • Manual refresh button to update the registration list
  • Requires debugEventsEnabled = true to be set on GetIt instance
  • See README for setup instructions

Update workflow to trigger on main branch

• Use absolute GitHub URL for logo in README

Update workflow to trigger on main branch

• Fixed screenshots description to match working 9.0.1 format

Update workflow to trigger on main branch

• Fixed logo display on pub.dev by using relative path

Update workflow to trigger on main branch

• Fixed button sizing in README for pub.dev display

Update workflow to trigger on main branch

Update workflow to trigger on main branch

• BREAKING: Disposal order now always follows strict LIFO (Last-In-First-Out) based on registration order
  • Previously, disposal order was based on the order objects appeared in internal hash maps, which was unpredictable when mixing named and unnamed registrations
  • Now all disposals are sorted by registrationNumber (a sequential counter assigned during registration) ensuring true LIFO order
  • The strictDisposalOrder parameter has been removed from reset(), resetScope(), popScope(), popScopesTill(), and dropScope() methods
  • Performance impact is minimal: ~8% overhead for 10,000 registrations (approximately 2-3ms), negligible for typical applications
  • This change ensures correctness and predictability in dependency cleanup, which is more important than the minor performance cost
  • Impact on existing apps: If your app's behavior relies on the previous imperfect reverse disposal order, there is likely a design issue in your dependency structure that should be addressed
• Fixed bug in registerCachedFactoryParamAsync where calling getAsync would fail with null error because it was checking the wrong function parameter (sync creationFunctionParam instead of asyncCreationFunctionParam)

• Reduce from 704 to 192 lines following README_TEMPLATE.md
• Add prominent docs link to flutter-it.dev
• Emphasize construction set philosophy
• Remove Flutter Community banner (preparing for own logo)
• Update blog post URLs to new blog.burkharts.net domain
• Add startup orchestration article link
• Streamline Quick Start with simple 3-step example
• Link detailed content to documentation site
• Update footer with flutter_it slogan

• adding cachedFatories and better scope protection against race conditions

• testing weak references in lazySingeltons

• adding changeTypeInstanceName

• fixing bug in unregister that happened if you tried to unregister a named registration by providing an instance instead of the type and the instance name

• releaseInstance will now throw if the instance isn't registered

• fixing negative reference count

• getAll() and getAllAsync() now have a fromAllScopes parameter.
• adding safeguards according to https://github.com/fluttercommunity/get_it/issues/364 to make it impossible to call push/popScope while the init() function of another pushScope is running.
• fixed an unsafe type check when using a runtime type to access an object in get_it.

• thanks to the PR by @kasefuchs https://github.com/fluttercommunity/get_it/pull/361 getAll is now available in an async version too.

• fig for bug that was introduced in 7.6.8 https://github.com/fluttercommunity/get_it/issues/358

• merged PR by @venkata-reddy-dev https://github.com/fluttercommunity/get_it/pull/356 adding new skipDoubleRegistration flag for testing

• merged PR by @subzero911 https://github.com/fluttercommunity/get_it/pull/330

• Thanks to PR by @bvoq getIt.reset, getIt.popScope, getIt.dropScope now dispose registered objects in the reverse order in which they were registered.

• fixed the throwing of a StateError that was previously thrown as String

• push new version because pub didn't list this one

• fix linter error

• added isFinal scope parameter which fixes https://github.com/fluttercommunity/get_it/issues/326
• version bump of dependencies and updates readme

• merged PR by lacopiroty https://github.com/fluttercommunity/get_it/pull/297 which now allows to access objects inside GetIt by runtime type too like

    getIt.registerSingleton(TestClass());

    final instance1 = getIt.get(type: TestClass);

    expect(instance1 is TestClass, true);

• fix for https://github.com/fluttercommunity/get_it/issues/299
• fix for https://github.com/fluttercommunity/get_it/issues/300

• new function dropScope(scopeName) which allows to remove and dispose any named scope even if it's not the top one. Great PR by @olexale https://github.com/fluttercommunity/get_it/pull/292 which fixes sort of race conditions if you create scopes just for the life time of a widget.

• Fix for https://github.com/fluttercommunity/get_it/issues/186

• Thanks to the clever PR https://github.com/fluttercommunity/get_it/pull/185 by @kmartins unregister and resetLazySingleton now only have to be awaited if you use an async disposal function.

• pushNewScope() now got an optional init parameter where you can pass a function that registers new objects inside the newly pushed Scope. Doing the registration in this function ensures that the onScopeChanged call-back is called after the objects are registered.

• The new Disposable interface had a typo that now got corrected. You could call this a breaking change but as the last version change is just three days old I guess not many people will be affected by this correction.

Getting notified when a scope change happens

When using scopes with objects that shadow other objects its important to give the UI a chance to rebuild and acquire references to the now active objects. For this you can register an call-back function in GetIt The getit_mixin has a matching rebuiltOnScopeChange method.

  /// Optional call-back that will get call whenever a change in the current scope happens
  /// This can be very helpful to update the UI in such a case to make sure it uses
  /// the correct Objects after a scope change
  void Function(bool pushed)? onScopeChanged;

This is a breaking change because there were some inconsistencies in the handling of the disposal functions that you can pass when registering an Object, pop a Scope or use unregister() resetLazySingleton(). Some of accepted a FutureOr method type, others just a void which meant you couldn't use async functions consistently. With this release you can use async functions in all disposal functions which unfortunately also required to change the signatures of the following functions:

  Future<void> reset({bool dispose = true});

  Future<void> resetScope({bool dispose = true});

  Future<void> popScope();

  Future<bool> popScopesTill(String name);

  FutureOr resetLazySingleton<T extends Object>({
    Object? instance,
    String? instanceName,
    FutureOr Function(T)? disposingFunction,
  });

  FutureOr unregister<T extends Object>({
    Object? instance,
    String? instanceName,
    FutureOr Function(T)? disposingFunction,
  });

Basically all functions that can possibly call a disposal functions should be awaited.

Implementing the Disposable interface

Instead of passing a disposing function on registration or when pushing a Scope from V7.0 on your objects onDispose() method will be called if the object that you register implements the Disposable´interface:

abstract class Disposable {
  FutureOr onDispose();
}

Getting notified about the shadowing state of an object

In some cases it might be helpful to know if an Object gets shadowed by another one e.g. if it has some Stream subscriptions that it want to cancel before the shadowing object creates a new subscription. Also the other way round so that a shadowed Object gets notified when it's "active" again meaning when a shadowing object is removed.

For this a class had to implement the ShadowChangeHandlers interface:

abstract class ShadowChangeHandlers {
  void onGetShadowed(Object shadowing);
  void onLeaveShadow(Object shadowing);
}

When the Object is shadowed its onGetShadowed() method is called with the object that is shadowing it. When this object is removed from GetIt onLeaveShadow() will be called.

• Thanks to this PR https://github.com/fluttercommunity/get_it/pull/181 by @n3wtron you can now also make objects depend on other objects not only by type but also by type and name if you used a named registration

• small fix in getAsync with parameters

• Exceptions that occur during an async initialisation are now forwarded to the future that allReady() returns instead to get swallowed https://github.com/fluttercommunity/get_it/issues/148
• Added a property currentScopeName to query the name of the currently active scope https://github.com/fluttercommunity/get_it/issues/153
• popScope will know throw an Exception instead just an assert if you are already on the baseScope and you try to pop it.

• Official null safety release

• fixed https://github.com/fluttercommunity/get_it/issues/138 when calling unRegister the dispose function that can be passed when registering wasn't called.

• fixed formatting in readme

• New scope support for registration
• optional dispose functions for registered objects
• Breaking change: reset() now is async and returns a Future because it will call the new optional disposal functions that can be async
• Breaking change: If you use names to register your objects you now have to provide a type too or at least make sure the compiler can infer the type. With this change it is now possible to use the same name for different types.

• experimental