Listeners renamed into observers

packages/yx_scope/example/bin/app_listener.dart

@@ -0,0 +1,111 @@
+import 'package:yx_scope/yx_scope.dart';
+import './main.dart';
+
+class AppScopeHolderWithListener extends ScopeHolder<AppScopeContainer> {
+  static const _listener = AppListener();
+
+  AppScopeHolderWithListener()
+      // ignore: deprecated_member_use
+      : super(scopeListeners: [_listener], depListeners: [_listener]);
+
+  @override
+  AppScopeContainer createContainer() => AppScopeContainer();
+}
+
+// ignore: deprecated_member_use
+class AppListener implements ScopeListener, DepListener, AsyncDepListener {
+  const AppListener();
+
+  static void _log(
+    String message, [
+    Object? exception,
+    StackTrace? stackTrace,
+  ]) {
+    print(message);
+    if (exception != null) {
+      print(exception);
+      if (stackTrace != null) {
+        print(stackTrace);
+      }
+    }
+  }
+
+  @override
+  void onScopeStartInitialize(ScopeId scope) =>
+      _log('[$scope] -> onScopeStartInitialize');
+
+  @override
+  void onScopeInitialized(ScopeId scope) =>
+      _log('[$scope] -> onScopeInitialized');
+
+  @override
+  void onScopeInitializeFailed(
+    ScopeId scope,
+    Object exception,
+    StackTrace stackTrace,
+  ) =>
+      _log('[$scope] -> onScopeInitializeFailed', exception, stackTrace);
+
+  @override
+  void onScopeStartDispose(ScopeId scope) =>
+      _log('[$scope] -> onScopeStartDispose');
+
+  @override
+  void onScopeDisposed(ScopeId scope) => _log('[$scope] -> onScopeDisposed');
+
+  @override
+  void onScopeDisposeDepFailed(
+    ScopeId scope,
+    DepId dep,
+    Object exception,
+    StackTrace stackTrace,
+  ) =>
+      _log('[$scope] -> onScopeDisposeDepFailed', exception, stackTrace);
+
+  @override
+  void onValueStartCreate(ScopeId scope, DepId dep) =>
+      _log('[$scope.$dep] -> onValueStartCreate');
+
+  @override
+  void onValueCreated(ScopeId scope, DepId dep, ValueMeta? valueMeta) =>
+      _log('[$scope.$dep] -> onValueCreated');
+
+  @override
+  void onValueCreateFailed(
+    ScopeId scope,
+    DepId dep,
+    Object exception,
+    StackTrace stackTrace,
+  ) =>
+      _log('[$scope.$dep] -> onValueCreated', exception, stackTrace);
+
+  @override
+  void onValueCleared(ScopeId scope, DepId dep, ValueMeta? valueMeta) =>
+      _log('[$scope.$dep]($valueMeta) -> onValueCleared');
+
+  @override
+  void onDepDisposeFailed(
+          ScopeId scope, DepId dep, Object exception, StackTrace stackTrace) =>
+      _log('[$scope.$dep] -> onDepDisposeFailed', exception, stackTrace);
+
+  @override
+  void onDepDisposed(ScopeId scope, DepId dep) =>
+      _log('[$scope.$dep] -> onDepDisposed');
+
+  @override
+  void onDepInitializeFailed(
+          ScopeId scope, DepId dep, Object exception, StackTrace stackTrace) =>
+      _log('[$scope.$dep] -> onDepInitializeFailed', exception, stackTrace);
+
+  @override
+  void onDepInitialized(ScopeId scope, DepId dep) =>
+      _log('[$scope.$dep] -> onDepInitialized');
+
+  @override
+  void onDepStartDispose(ScopeId scope, DepId dep) =>
+      _log('[$scope.$dep] -> onDepStartDispose');
+
+  @override
+  void onDepStartInitialize(ScopeId scope, DepId dep) =>
+      _log('[$scope.$dep] -> onDepStartInitialize');
+}

packages/yx_scope/example/bin/deprecated_listeners_main.dart

@@ -0,0 +1,15 @@
+import 'app_listener.dart';
+
+/// This file will be deleted in the next major version
+/// when Listeners will be completely removed
+void main() async {
+  final appScopeHolderWithListener = AppScopeHolderWithListener();
+
+  await appScopeHolderWithListener.create();
+
+  print(appScopeHolderWithListener.scope?.routerDelegateDep.get);
+
+  await appScopeHolderWithListener.drop();
+
+  print(appScopeHolderWithListener.scope?.routerDelegateDep.get);
+}

packages/yx_scope/example/bin/main.dart

@@ -31,17 +31,17 @@ class AppScopeContainer extends ScopeContainer {
 }
 
 class AppScopeHolder extends ScopeHolder<AppScopeContainer> {
-  static const _listener = AppListener();
+  static const _observer = AppObserver();
 
   AppScopeHolder()
-      : super(scopeListeners: [_listener], depListeners: [_listener]);
+      : super(scopeObservers: [_observer], depObservers: [_observer]);
 
   @override
   AppScopeContainer createContainer() => AppScopeContainer();
 }
 
-class AppListener implements ScopeListener, DepListener {
-  const AppListener();
+class AppObserver implements ScopeObserver, DepObserver, AsyncDepObserver {
+  const AppObserver();
 
   static void _log(
     String message, [
@@ -109,4 +109,30 @@ class AppListener implements ScopeListener, DepListener {
   @override
   void onValueCleared(ScopeId scope, DepId dep, ValueMeta? valueMeta) =>
       _log('[$scope.$dep]($valueMeta) -> onValueCleared');
+
+  @override
+  void onDepDisposeFailed(
+          ScopeId scope, DepId dep, Object exception, StackTrace stackTrace) =>
+      _log('[$scope.$dep] -> onDepDisposeFailed', exception, stackTrace);
+
+  @override
+  void onDepDisposed(ScopeId scope, DepId dep) =>
+      _log('[$scope.$dep] -> onDepDisposed');
+
+  @override
+  void onDepInitializeFailed(
+          ScopeId scope, DepId dep, Object exception, StackTrace stackTrace) =>
+      _log('[$scope.$dep] -> onDepInitializeFailed', exception, stackTrace);
+
+  @override
+  void onDepInitialized(ScopeId scope, DepId dep) =>
+      _log('[$scope.$dep] -> onDepInitialized');
+
+  @override
+  void onDepStartDispose(ScopeId scope, DepId dep) =>
+      _log('[$scope.$dep] -> onDepStartDispose');
+
+  @override
+  void onDepStartInitialize(ScopeId scope, DepId dep) =>
+      _log('[$scope.$dep] -> onDepStartInitialize');
 }

packages/yx_scope/lib/advanced.dart

@@ -1 +1 @@
-export 'src/monitoring/raw_listeners.dart';
+export 'src/monitoring/raw_observers.dart';

packages/yx_scope/lib/src/base_scope_container.dart

@@ -6,11 +6,11 @@ import 'package:meta/meta.dart';
 import 'core/async_lifecycle.dart';
 import 'core/scope_exception.dart';
 import 'core/scope_state.dart';
-import 'monitoring/listeners.dart';
+import 'monitoring/observers.dart';
 import 'monitoring/models/dep_id.dart';
 import 'monitoring/models/scope_id.dart';
 import 'monitoring/models/value_meta.dart';
-import 'monitoring/raw_listeners.dart';
+import 'monitoring/raw_observers.dart';
 import 'monitoring/scope_observatory_internal.dart';
 import 'scope_container.dart';
 import 'scope_state_streamable.dart';
@@ -21,7 +21,7 @@ part 'core_scope_holder.dart';
 
 part 'dep.dart';
 
-part 'monitoring/listeners_internal.dart';
+part 'monitoring/observers_internal.dart';
 
 part 'monitoring/models/scope_meta.dart';
 
@@ -70,15 +70,15 @@ abstract class BaseScopeContainer extends Scope {
   final String? _name;
   late final ScopeId _id;
 
-  late final DepListenerInternal _depListener;
-  late final AsyncDepListenerInternal _asyncDepListener;
+  late final DepObserverInternal _depObserver;
+  late final AsyncDepObserverInternal _asyncDepObserver;
 
   BaseScopeContainer({String? name})
       : _name = name,
         super._() {
     _id = ScopeId(runtimeType, hashCode, _name);
-    _depListener = DepListenerInternal(this);
-    _asyncDepListener = AsyncDepListenerInternal(this);
+    _depObserver = DepObserverInternal(this);
+    _asyncDepObserver = AsyncDepObserverInternal(this);
   }
 
   /// A queue of the initialization for [AsyncDep].
@@ -118,7 +118,7 @@ abstract class BaseScopeContainer extends Scope {
     DepBuilder<Value> builder, {
     String? name,
   }) =>
-      Dep._(this, builder, name: name, listener: _depListener);
+      Dep._(this, builder, name: name, observer: _depObserver);
 
   /// Exactly the same as [BaseScopeContainer.dep] but you only allowed
   /// to declare [AsyncLifecycle] dependencies using this method.
@@ -160,7 +160,7 @@ abstract class BaseScopeContainer extends Scope {
         init: init,
         dispose: dispose,
         name: name,
-        listener: _asyncDepListener,
+        observer: _asyncDepObserver,
       );
 
   void _registerDep(Dep dep) => _container.add(dep);

packages/yx_scope/lib/src/core_scope_holder.dart

@@ -8,22 +8,36 @@ part of 'base_scope_container.dart';
 /// This is the core entity that provides access to the [BaseScopeContainer].
 abstract class CoreScopeHolder<Scope, Container extends BaseScopeContainer>
     extends ScopeStateHolder<Scope?> with ScopeStateStreamable<Scope?> {
-  final ScopeListenerInternal _scopeListenerInternal;
-  final List<DepListener>? _depListeners;
-  final List<AsyncDepListener>? _asyncDepListeners;
+  final ScopeObserverInternal _scopeObserverInternal;
+  final List<DepObserver>? _depObservers;
+  final List<AsyncDepObserver>? _asyncDepObservers;
 
   final _scopeStateHolder = ScopeStateHolder<ScopeState>(ScopeState.none);
   Completer? _waitLifecycleCompleter;
 
   ScopeState get _scopeState => _scopeStateHolder.scope;
 
   CoreScopeHolder({
+    List<ScopeObserver>? scopeObservers,
+    List<DepObserver>? depObservers,
+    List<AsyncDepObserver>? asyncDepObservers,
+    // ignore: deprecated_member_use_from_same_package
+    @Deprecated('Use scopeObservers instead')
     List<ScopeListener>? scopeListeners,
-    List<DepListener>? depListeners,
+    // ignore: deprecated_member_use_from_same_package
+    @Deprecated('Use depObservers instead') List<DepListener>? depListeners,
+    // ignore: deprecated_member_use_from_same_package
+    @Deprecated('Use asyncDepObservers instead')
     List<AsyncDepListener>? asyncDepListeners,
-  })  : _scopeListenerInternal = ScopeListenerInternal(scopeListeners),
-        _depListeners = depListeners,
-        _asyncDepListeners = asyncDepListeners,
+  })  : assert(!(scopeListeners != null && scopeObservers != null),
+            'Both scopeObservers and scopeListeners passed as arguments to ScopeHolder. Consider using only scopeObservers'),
+        assert(!(depListeners != null && depObservers != null),
+            'Both depObservers and depListeners passed as arguments to ScopeHolder. Consider using only depObservers'),
+        assert(!(asyncDepListeners != null && asyncDepObservers != null),
+            'Both asyncDepObservers and asyncDepListeners passed as arguments to ScopeHolder. Consider using only asyncDepObservers'),
+        _scopeObserverInternal = ScopeObserverInternal(scopeObservers),
+        _depObservers = depObservers,
+        _asyncDepObservers = asyncDepObservers,
         super(null);
 
   /// Initialize scope. [Scope] becomes available and everyone can
@@ -116,9 +130,9 @@ abstract class CoreScopeHolder<Scope, Container extends BaseScopeContainer>
         break;
     }
 
-    _prepareListeners(scope);
+    _prepareObservers(scope);
 
-    _scopeListenerInternal.onScopeStartInitialize(scope);
+    _scopeObserverInternal.onScopeStartInitialize(scope);
 
     _initializing();
 
@@ -154,13 +168,13 @@ abstract class CoreScopeHolder<Scope, Container extends BaseScopeContainer>
         );
       }
     } on Object catch (e, s) {
-      _scopeListenerInternal.onScopeInitializeFailed(scope, e, s);
+      _scopeObserverInternal.onScopeInitializeFailed(scope, e, s);
 
       await _drop(initializedScope: scope, initializedDeps: initialized);
       rethrow;
     }
     _available(scope as Scope);
-    _scopeListenerInternal.onScopeInitialized(scope);
+    _scopeObserverInternal.onScopeInitialized(scope);
   }
 
   /// Dispose scope. [Scope] becomes unavailable.
@@ -281,7 +295,7 @@ abstract class CoreScopeHolder<Scope, Container extends BaseScopeContainer>
       );
     }
 
-    _scopeListenerInternal.onScopeStartDispose(scope);
+    _scopeObserverInternal.onScopeStartDispose(scope);
 
     _disposing();
 
@@ -310,7 +324,7 @@ abstract class CoreScopeHolder<Scope, Container extends BaseScopeContainer>
                 e,
                 s,
               );
-              _scopeListenerInternal.onScopeDisposeDepFailed(
+              _scopeObserverInternal.onScopeDisposeDepFailed(
                 scope,
                 dep,
                 e,
@@ -325,9 +339,9 @@ abstract class CoreScopeHolder<Scope, Container extends BaseScopeContainer>
       );
     }
     scope._unregister();
-    _clearListeners(scope);
+    _clearObservers(scope);
     await _disposed();
-    _scopeListenerInternal.onScopeDisposed(scope);
+    _scopeObserverInternal.onScopeDisposed(scope);
   }
 
   // ignore: use_setters_to_change_properties
@@ -358,15 +372,15 @@ abstract class CoreScopeHolder<Scope, Container extends BaseScopeContainer>
 
   void _disposing() => _updateScope(ScopeState.disposing);
 
-  void _prepareListeners(Container scope) {
-    scope._depListener._listeners = _depListeners;
-    scope._asyncDepListener._listeners = _asyncDepListeners;
-    scope._asyncDepListener._asyncDepListeners = _asyncDepListeners;
+  void _prepareObservers(Container scope) {
+    scope._depObserver._observers = _depObservers;
+    scope._asyncDepObserver._observers = _asyncDepObservers;
+    scope._asyncDepObserver._asyncDepObservers = _asyncDepObservers;
   }
 
-  void _clearListeners(Container scope) {
-    scope._depListener._listeners = null;
-    scope._asyncDepListener._listeners = null;
-    scope._asyncDepListener._asyncDepListeners = null;
+  void _clearObservers(Container scope) {
+    scope._depObserver._observers = null;
+    scope._asyncDepObserver._observers = null;
+    scope._asyncDepObserver._asyncDepObservers = null;
   }
 }