Flutter Custom State Management

What I am trying to achieve is a small custom state management solution that I believe is powerful enough to run small and large apps. The core is based on the ValueNotifier and ValueListenable concepts in flutter. The data can be accessed anywhere in the app with out context since I am storing the data like this:

class UserData {
  static ValueNotifier<DataLoader<User>> userData =
      ValueNotifier(DataLoader<User>());

  static Future<User> loadUserData() async {
    await Future.delayed(const Duration(seconds: 3));
    User user = User();
    user.age = 23;
    user.family = 'Naoushy';
    user.name = 'Anass';
    return user;
  }
}

So by using UserData.userData you can use the data of the user whenever you want. Everything works fine until I encountered a problem of providing a child to my custom data consumer that rebuilds the widget when there is a new event fired. The DataLoader class looks like this:

enum Status { none, hasError, loading, loaded }

class DataLoader<T> {
  Status status = Status.none;
  T? data;
  Object? error;
  bool get hasError => error != null;
  bool get hasData => data != null;
}

which is very simple. Now the class for consuming the data and rebuilding looks like this:

import 'dart:developer';

import 'package:flutter/material.dart';
import 'package:testing/utils/dataLoader/data_loader.dart';

class DataLoaderUI<T> extends StatefulWidget {
  final ValueNotifier<DataLoader<T>> valueNotifier;
  final Widget noneStatusUI;
  final Widget hasErrorUI;
  final Widget loadingUI;
  final Widget child;
  final Future<T> future;
  const DataLoaderUI(
      {Key? key,
      required this.valueNotifier,
      this.noneStatusUI = const Text('Data initialization has not started'),
      this.hasErrorUI = const Center(child: Text('Unable to fetch data')),
      this.loadingUI = const Center(
        child: CircularProgressIndicator(),
      ),
      required this.child,
      required this.future})
      : super(key: key);

  @override
  State<DataLoaderUI> createState() => _DataLoaderUIState();
}

class _DataLoaderUIState extends State<DataLoaderUI> {
  Future startLoading() async {
    widget.valueNotifier.value.status = Status.loading;
    widget.valueNotifier.notifyListeners();
    try {
      var data = await widget.future;
      widget.valueNotifier.value.data = data;
      widget.valueNotifier.value.status = Status.loaded;
      widget.valueNotifier.notifyListeners();
    } catch (e) {
      log('future error', error: e.toString());
      widget.valueNotifier.value.error = e;
      widget.valueNotifier.value.status = Status.hasError;
      widget.valueNotifier.notifyListeners();
    }
  }

  @override
  void initState() {
    super.initState();
    log('init state launched');
    if (!widget.valueNotifier.value.hasData) {
      log('reloading or first loading');
      startLoading();
    }
  }

  //AsyncSnapshot asyncSnapshot;
  @override
  Widget build(BuildContext context) {
    return ValueListenableBuilder<DataLoader>(
        valueListenable: widget.valueNotifier,
        builder: (context, dataLoader, ui) {
          if (dataLoader.status == Status.none) {
            return widget.noneStatusUI;
          } else if (dataLoader.status == Status.hasError) {
            return widget.hasErrorUI;
          } else if (dataLoader.status == Status.loading) {
            return widget.loadingUI;
          } else {
            return widget.child;
          }
        });
  }
}

which is also simple yet very effective. since even if the initState function is relaunched if the data is already fetched the Future will not relaunch. I am using the class like this:

class TabOne extends StatefulWidget {
  static Tab tab = const Tab(
    icon: Icon(Icons.upload),
  );
  const TabOne({Key? key}) : super(key: key);

  @override
  State<TabOne> createState() => _TabOneState();
}

class _TabOneState extends State<TabOne> {
  @override
  Widget build(BuildContext context) {
    return DataLoaderUI<User>(
        valueNotifier: UserData.userData,
        future: UserData.loadUserData(),
        child: Text(UserData.userData.value.data!.name??'No name'));
  }
}

The error is in this line:

Text(UserData.userData.value.data!.name??'No name'));

Null check operator used on a null value Since I am passing the Text widget as an argument with the data inside it. Flutter is trying to pass it but not able to since there is no data yet so its accessing null values. I tried with a normal string and it works perfectly. I looked at the FutureBuilder widget and they use a kind of builder and also the ValueLisnableBuilder has a builder as an arguement. The problem is that I am not capable of creating something like it for my custom solution. How can I just pass the child that I want without having such an error and without moving the ValueLisnable widget into my direct UI widget?