How to create a mixin for advanced enum and use it in a generic widget?

My goal is to write a generic Widget that, in this case, enables the user for selecting an enum value among all the values from the enum.

So I'd like to write something like so:

class WheelPickerWidget<T extends Enum> extends StatelessWidget {
  /// The initial value
  final T? value;

  /// The onChanged callback
  final void Function(T)? onChanged;

  /// Retuns the wheel enum picker
  const WheelPickerWidget(
      {super.key, required this.value, required this.onChanged});

  @override
  Widget build(BuildContext context) {
    return ListWheelScrollView(
        physics: const BouncingScrollPhysics(),
        itemExtent: 50,
        diameterRatio: 0.6,
        //offAxisFraction: -0.4,
        squeeze: 1.8,
        //useMagnifier: true,
        //overAndUnderCenterOpacity: 0.8,
        clipBehavior: Clip.antiAlias,
        onSelectedItemChanged: (value) => onChanged?.call(T.fromValue(value)),
        children: T.values.map((c) => Text("$c")).toList());
  }
}

But I see T.fromValues() and T.values are generating errors as follows:

> The method 'fromValue' isn't defined for the type 'Type'.
Try correcting the name to the name of an existing method, or defining a method named 'fromValue'.

> The getter 'values' isn't defined for the type 'Type'.
Try importing the library that defines 'values', correcting the name to the name of an existing getter, or defining a getter or field named 'values'.

I usually write my enums as follows:

/// Theme to use for the app
enum AppTheme {
  green(0),
  yellow(1),
  nightBlue(2);

  const AppTheme(this.value);
  final int value;

  factory AppTheme.fromValue(int v) => values.firstWhere((x) => x.value == v,
      orElse: () => throw Exception("Unknown value $v"));

  /// Returns the name corresponding to the enum
  @override
  String toString() {
    switch (this) {
      case green:
        return i18n_Green.i18n;
      case yellow:
        return i18n_Yellow.i18n;
      case nightBlue:
        return i18n_Night_blue.i18n;
    }
  }
}

Where I make fromValue() readily available.

And I guess I could use mixin to create a specific form of enum that complies to the requirements.

/// Advanced enum
mixin EnumMixin {
}

But I didn't manage to do it: one reason is the factory cannot be supported by the mixin.

So to sum up, my questions are:

1. How to make my wheel picker class works with my enum?;
2. How to create a generic way (possibly being a mixin) to conform all my enums to a way it can be supported by my generic wheel picker?

You cannot make T.someConstructor() or T.someStaticMethod() work for some generic type T. Dart does not consider constructors and static methods to be part of the class interface, and they are not inherited.

In general, whenever you want to use something like T.someConstructor() or T.someStaticMethod(), you're probably better off using a callback instead. Similarly, instead of using T.values, you can accept a List<T> argument.

For example:

class WheelPickerWidget<T extends Enum> extends StatelessWidget {
  WheelPickerWidget({required this.values, required this.fromValue});

  final List<T> values;
  final T Function(int) fromValue;

  ...

  @override
  Widget build(BuildContext context) {
    return ListWheelScrollView(
        ...
        onSelectedItemChanged: (value) => onChanged?.call(fromValue(value)),
        children: values.map((c) => Text("$c")).toList());
  }
}

and then callers would use:

WheelPickerWidget(values: AppTheme.values, fromValue: AppTheme.fromValue);

Note that fromValue is a bit redundant in principle if you already have values; you could just iterate over values to find the Enum you want. For example, you could do:

abstract class HasValue<T> {
  T get value;
}

enum AppTheme implements HasValue<int> {
  green(0),
  yellow(1),
  nightBlue(2);

  const AppTheme(this.value);

  @override
  final int value;

  ...
}

class WheelPickerWidget<T extends Enum> extends StatelessWidget {
  WheelPickerWidget({required this.values})

  final List<T> values;

  ...

  @override
  Widget build(BuildContext context) {
    return ListWheelScrollView(
        ...
        onSelectedItemChanged: (value) => onChanged?.call(values.findValue(value)),
        children: values.map((c) => Text("$c")).toList());
  }
}

extension<T extends Enum> on List<T> {
  T findValue<U>(U value) {
    for (Object e in this) {
      if (e is HasValue<U> && e.value == value) {
        return e as T;
      }
    }
    throw Exception("Unknown value $value");
  }
}

Unfortunately, findValue is slightly awkward because there doesn't seem to be a good way to enforce that T derives from both Enum and HasValue, so it must perform runtime type-checking. Additionally, Dart will not perform automatic type promotion between unrelated types (in this case, Enum and HasValue), so findValue upcasts to Object first as a workaround.

If you don't want callers to pass extra arguments, one alternative would be to store those arguments in a global lookup table with the generic type as the key. This isn't a great general approach since a Map<Type, ...> depends on exact Type matches, so looking up a subtype wouldn't match a supertype in the Map. However, Enums are not allowed to be extended nor implemented, so that is not a concern. I would consider it to be less robust, however, since it would require extra work to initialize such a Map, and there's no way at compile-time that it's been initialized with all of the types you care about. As an example of how this could look:

final _fromValueMap = <Type, Enum Function(int)>{
  AppTheme: AppTheme.fromValue,
};

final _lookupValuesMap = <Type, List<Enum>>{
  AppTheme: AppTheme.values,
};

T fromValue<T>(int value) => _fromValueMap[T]!(value) as T;

List<T> lookupValues<T>() => _lookupValuesMap[T]! as List<T>;

class WheelPickerWidget<T extends Enum> extends StatelessWidget {
  ...

  @override
  Widget build(BuildContext context) {
    return ListWheelScrollView(
        ...
        onSelectedItemChanged: (value) => onChanged?.call(fromValue<T>(value)),
        children: lookupValues<T>().map((c) => Text("$c")).toList());
  }
}