Thoughts on providers in a static class for the sake of namespace?

[Norbert515]

Sometimes there are a couple of providers that work together to achieve a function.

For example:

final registrationButtonEnabledProvider = Provider.autoDispose<bool>((ref) {
  var email = ref.watch(registrationEmailStateProvider).state;
  var password = ref.watch(registrationPasswordStateProvider).state;
  var passwordConfirm = ref.watch(registrationPasswordConfirmStateProvider).state;

  if(email.isEmpty || password.isEmpty || passwordConfirm.isEmpty) {
    return false;
  }

  if(!PasswordValidator.checkPassword(password).conformsToRequirements) {
    return false;
  }

  return ref.watch(registrationStateNotifierProvider).canRegister;
});

/// The [StateProvider] to set the email state
///
/// This is supposed to be only used by the [RegistrationPage]
final registrationEmailStateProvider = StateProvider.autoDispose<String>((ref) {
  return '';
});

/// The [StateProvider] to set the password state
///
/// This is supposed to be only used by the [RegistrationPage]
final registrationPasswordStateProvider = StateProvider.autoDispose<String>((ref) {
  return '';
});

/// The [StateProvider] to set the password confirm state
///
/// This is supposed to be only used by the [RegistrationPage]
final registrationPasswordConfirmStateProvider = StateProvider.autoDispose<String>((ref) {
  return '';
});

handles TextFields and whether to enable the register button. These are only meant to be used by one class.

If I create a lot of such providers, my concern is that it might convolute the global namespace and make API discovery harder when the project grows.

I was thinking of putting these in a static class, purely for the sake of namespace.

class RegistrationForm {

    static final registrationButtonEnabledProvider = Provider.autoDispose<bool>((ref) {
      var email = ref.watch(registrationEmailStateProvider).state;
      var password = ref.watch(registrationPasswordStateProvider).state;
      var passwordConfirm = ref.watch(registrationPasswordConfirmStateProvider).state;
    
      if(email.isEmpty || password.isEmpty || passwordConfirm.isEmpty) {
        return false;
      }
    
      if(!PasswordValidator.checkPassword(password).conformsToRequirements) {
        return false;
      }
    
      return ref.watch(registrationStateNotifierProvider).canRegister;
    });
    
    /// The [StateProvider] to set the email state
    ///
    /// This is supposed to be only used by the [RegistrationPage]
    static final registrationEmailStateProvider = StateProvider.autoDispose<String>((ref) {
      return '';
    });
    
    /// The [StateProvider] to set the password state
    ///
    /// This is supposed to be only used by the [RegistrationPage]
    static final registrationPasswordStateProvider = StateProvider.autoDispose<String>((ref) {
      return '';
    });
    
    /// The [StateProvider] to set the password confirm state
    ///
    /// This is supposed to be only used by the [RegistrationPage]
    static final registrationPasswordConfirmStateProvider = StateProvider.autoDispose<String>((ref) {
      return '';
    });
}

I haven't seen this done yet, and I'd love to hear opinions.

[rrousselGit]

This isn't that uncommon

While there isn't a "This is how you should triage your providers" guideline yet, grouping providers as static final is a common solution.
It's great when there's a clear group

The downside is, not all providers fit inside such namespace. So it makes the syntax for using providers a bit inconsistent. Sometimes we'll have watch(Class.provider) and sometimes watch(provider).

But yeah, go for it :)