`reactive_forms_generator` 8.0.0: Generated `FormArrayBuilder` code causes build error due to nullability mismatch with `FormModel.of(context)` when using `freezed`

[smithemely]

After upgrading reactive_forms_generator to 8.0.0, our application, which uses reactive_forms in conjunction with freezed for model definitions, fails to build. The error originates in the generated Reactive<YourFormName>FormArrayBuilder (e.g., ReactiveTestFormFormArrayBuilder).

The problematic line in the generated code is:

formArray: formControl ?? control?.call(ReactiveTestFormForm.of(context)),

The issue is that ReactiveTestFormForm.of(context) (or Reactive<YourFormName>Form.of(context)) can return null:

static TestFormForm? of( // Or YourFormNameForm?
    BuildContext context, {
    bool listen = true,
  }) {
    // ... implementation returns TestFormForm?
  }

However, the control callback in the ReactiveTestFormFormArrayBuilder expects a non-nullable formModel:

final FormArray<ReactiveTestFormFormArrayBuilderT>? Function(
      TestFormForm formModel)? control; // Or YourFormNameForm

This leads to a compile-time error because a potentially null value from .of(context) is passed to the control callback which expects a non-null argument.

To Reproduce:

1. Define a form model using freezed and annotate it with @Rf().
   Example model structure:

   import 'package:freezed_annotation/freezed_annotation.dart';
   import 'package:reactive_forms_annotations/reactive_forms_annotations.dart';
   
   part 'test_form.freezed.dart';
   part 'test_form.g.dart';
   part 'test_form.gform.dart';
   
   @freezed
   @Rf()
   sealed class TestForm with _$TestForm {
     const factory TestForm({
       @RfControl() required String someField,
     }) = _TestForm;
   
     factory TestForm.fromJson(Map<String, dynamic> json) =>
         _$TestFormFromJson(json);
   }

2. Generate code using reactive_forms_generator: ^8.0.0.
3. Attempt to build the application.

Expected Behavior:
The generated code should correctly handle the potential nullability of FormModel.of(context) to prevent build errors, perhaps by adding a null check or an assertion that FormModel.of(context) is not null in this specific context if it's guaranteed.

Affected Generated Code Snippet (example for a form named TestForm):

class ReactiveTestFormFormArrayBuilder<ReactiveTestFormFormArrayBuilderT> // Suffix might vary based on array property name
    extends StatelessWidget {
  // ...
  final FormArray<ReactiveTestFormFormArrayBuilderT>? Function(
      TestFormForm formModel)? control; // Expects non-nullable TestFormForm
  // ...
  @override
  Widget build(BuildContext context) {
    return ReactiveFormArray<ReactiveTestFormFormArrayBuilderT>(
      formArray: formControl ?? control?.call(ReactiveTestFormForm.of(context)), // ReactiveTestFormForm.of(context) can be null
      // ...
    );
  }
}

Environment:

• Flutter: 3.32.2
• Dart: 3.8.1

Package Versions:

• reactive_forms: ^18.0.0
• reactive_forms_annotations: ^8.0.0
• reactive_forms_generator: ^8.0.0
• freezed: ^3.0.6
• freezed_annotation: ^3.0.0
• json_annotation: ^4.9.0
• json_serializable: ^6.9.5
• build_runner: ^2.4.15

[smithemely]

And an another error:

Undefined name 'formModel'.
Try correcting the name to one that is defined, or defining the name.

on that generated block of code:

  @override
  Widget build(BuildContext context) {
    return ReactiveFormArray<ReactiveTestFormFormArrayBuilderT>(
      formArray:
          formControl ?? control?.call(ReactiveTestFormForm.of(context)),
      builder: (context, formArray, child) {
        final values =
            formArray.controls.indexed
                .where(
                  (e) =>
                      controlFilter?.call(
                        e.$2
                            as FormControl<
                              ReactiveTestFormFormArrayBuilderT
                            >,
                      ) ??
                      true,
                )
                .toList();

        final itemList =
            values
                .map((item) {
                  return MapEntry(
                    item.$1,
                    itemBuilder(
                      context,
                      item.$1,
                      formArray.controls[item.$1]
                          as FormControl<ReactiveTestFormFormArrayBuilderT>,
                      item.$2.value,
                      formModel, // Error there
                    ),
                  );
                })
                .map((e) => e.value)
                .toList();

        if (emptyBuilder != null && itemList.isEmpty) {
          return emptyBuilder!(context);
        }

        return builder?.call(context, itemList, formModel) ?? // Error there
            Column(children: itemList);
      },
    );
  }

for some reason it misses the:

final formModel = ReactiveFormResponseForm.of(context);

[smithemely]

Downgrading to the strict 8.0.0-beta0 version is a workaround:

• reactive_forms_annotations: 8.0.0-beta0
• reactive_forms_generator: 8.0.0-beta0

flutter pub downgrade reactive_forms_generator

[giboin]

Hi! Got the same even without freezed :
flutter : 3.32.2
build_runner : 2.4.15
reactive_forms : 18.0.0
reactive_forms_annotations : 8.0.0
reactive_forms_generator : 8.0.0

login_form.dart

import 'package:equatable/equatable.dart';
import 'package:reactive_forms_annotations/reactive_forms_annotations.dart';

part 'login_form.gform.dart';

@Rf()
class Login extends Equatable {
  const Login({
    @RfControl(validators: [RequiredValidator()]) this.identifier = '',
    @RfControl(validators: [RequiredValidator()]) this.password = '',
  });

  final String identifier;
  final String password;

  @override
  List<Object?> get props => [identifier, password];
}

generated code - login_form.gform

// coverage:ignore-file
// GENERATED CODE - DO NOT MODIFY BY HAND
// ignore_for_file: type=lint
// ignore_for_file: unused_element, deprecated_member_use, deprecated_member_use_from_same_package, use_function_type_syntax_for_parameters, unnecessary_const, avoid_init_to_null, invalid_override_different_default_values_named, prefer_expression_function_bodies, annotate_overrides, invalid_annotation_target, unnecessary_question_mark

part of 'login_form.dart';

// **************************************************************************
// ReactiveFormsGenerator
// **************************************************************************

class ReactiveLoginFormConsumer extends StatelessWidget {
  const ReactiveLoginFormConsumer({Key? key, required this.builder, this.child})
    : super(key: key);

  final Widget? child;

  final Widget Function(
    BuildContext context,
    LoginForm formModel,
    Widget? child,
  )
  builder;

  @override
  Widget build(BuildContext context) {
    final formModel = ReactiveLoginForm.of(context);

    if (formModel is! LoginForm) {
      throw FormControlParentNotFoundException(this);
    }
    return builder(context, formModel, child);
  }
}

class LoginFormInheritedStreamer extends InheritedStreamer<dynamic> {
  const LoginFormInheritedStreamer({
    Key? key,
    required this.form,
    required Stream<dynamic> stream,
    required Widget child,
  }) : super(stream, child, key: key);

  final LoginForm form;
}

class ReactiveLoginForm extends StatelessWidget {
  const ReactiveLoginForm({
    Key? key,
    required this.form,
    required this.child,
    this.canPop,
    this.onPopInvokedWithResult,
  }) : super(key: key);

  final Widget child;

  final LoginForm form;

  final bool Function(FormGroup formGroup)? canPop;

  final ReactiveFormPopInvokedWithResultCallback<dynamic>?
  onPopInvokedWithResult;

  static LoginForm? of(BuildContext context, {bool listen = true}) {
    if (listen) {
      return context
          .dependOnInheritedWidgetOfExactType<LoginFormInheritedStreamer>()
          ?.form;
    }

    final element = context
        .getElementForInheritedWidgetOfExactType<LoginFormInheritedStreamer>();
    return element == null
        ? null
        : (element.widget as LoginFormInheritedStreamer).form;
  }

  @override
  Widget build(BuildContext context) {
    return LoginFormInheritedStreamer(
      form: form,
      stream: form.form.statusChanged,
      child: ReactiveFormPopScope(
        canPop: canPop,
        onPopInvokedWithResult: onPopInvokedWithResult,
        child: child,
      ),
    );
  }
}

extension ReactiveReactiveLoginFormExt on BuildContext {
  LoginForm? loginFormWatch() => ReactiveLoginForm.of(this);

  LoginForm? loginFormRead() => ReactiveLoginForm.of(this, listen: false);
}

class LoginFormBuilder extends StatefulWidget {
  const LoginFormBuilder({
    Key? key,
    this.model,
    this.child,
    this.canPop,
    this.onPopInvokedWithResult,
    required this.builder,
    this.initState,
  }) : super(key: key);

  final Login? model;

  final Widget? child;

  final bool Function(FormGroup formGroup)? canPop;

  final ReactiveFormPopInvokedWithResultCallback<dynamic>?
  onPopInvokedWithResult;

  final Widget Function(
    BuildContext context,
    LoginForm formModel,
    Widget? child,
  )
  builder;

  final void Function(BuildContext context, LoginForm formModel)? initState;

  @override
  _LoginFormBuilderState createState() => _LoginFormBuilderState();
}

class _LoginFormBuilderState extends State<LoginFormBuilder> {
  late LoginForm _formModel;

  StreamSubscription<LogRecord>? _logSubscription;

  @override
  void initState() {
    _formModel = LoginForm(LoginForm.formElements(widget.model), null);

    if (_formModel.form.disabled) {
      _formModel.form.markAsDisabled();
    }

    widget.initState?.call(context, _formModel);

    _logSubscription = _logLoginForm.onRecord.listen((LogRecord e) {
      // use `dumpErrorToConsole` for severe messages to ensure that severe
      // exceptions are formatted consistently with other Flutter examples and
      // avoids printing duplicate exceptions
      if (e.level >= Level.SEVERE) {
        final Object? error = e.error;
        FlutterError.dumpErrorToConsole(
          FlutterErrorDetails(
            exception: error is Exception ? error : Exception(error),
            stack: e.stackTrace,
            library: e.loggerName,
            context: ErrorDescription(e.message),
          ),
        );
      } else {
        log(
          e.message,
          time: e.time,
          sequenceNumber: e.sequenceNumber,
          level: e.level.value,
          name: e.loggerName,
          zone: e.zone,
          error: e.error,
          stackTrace: e.stackTrace,
        );
      }
    });

    super.initState();
  }

  @override
  void didUpdateWidget(covariant LoginFormBuilder oldWidget) {
    if (widget.model != oldWidget.model) {
      _formModel.updateValue(widget.model);
    }

    super.didUpdateWidget(oldWidget);
  }

  @override
  void dispose() {
    _formModel.form.dispose();
    _logSubscription?.cancel();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return ReactiveLoginForm(
      key: ObjectKey(_formModel),
      form: _formModel,
      // canPop: widget.canPop,
      // onPopInvoked: widget.onPopInvoked,
      child: ReactiveFormBuilder(
        form: () => _formModel.form,
        canPop: widget.canPop,
        onPopInvokedWithResult: widget.onPopInvokedWithResult,
        builder: (context, formGroup, child) =>
            widget.builder(context, _formModel, widget.child),
        child: widget.child,
      ),
    );
  }
}

final _logLoginForm = Logger.detached('LoginForm');

class LoginForm implements FormModel<Login, Login> {
  LoginForm(this.form, this.path);

  static const String identifierControlName = "identifier";

  static const String passwordControlName = "password";

  final FormGroup form;

  final String? path;

  final Map<String, bool> _disabled = {};

  String identifierControlPath() => pathBuilder(identifierControlName);

  String passwordControlPath() => pathBuilder(passwordControlName);

  String get _identifierValue => identifierControl.value ?? '';

  String get _passwordValue => passwordControl.value ?? '';

  String get _identifierRawValue => identifierControl.value ?? '';

  String get _passwordRawValue => passwordControl.value ?? '';

  @Deprecated(
    'Generator completely wraps the form and ensures at startup that all controls are present inside the form so we do not need this additional step',
  )
  bool get containsIdentifier {
    try {
      form.control(identifierControlPath());
      return true;
    } catch (e) {
      return false;
    }
  }

  @Deprecated(
    'Generator completely wraps the form and ensures at startup that all controls are present inside the form so we do not need this additional step',
  )
  bool get containsPassword {
    try {
      form.control(passwordControlPath());
      return true;
    } catch (e) {
      return false;
    }
  }

  Map<String, Object> get identifierErrors => identifierControl.errors;

  Map<String, Object> get passwordErrors => passwordControl.errors;

  void get identifierFocus => form.focus(identifierControlPath());

  void get passwordFocus => form.focus(passwordControlPath());

  void identifierValueUpdate(
    String value, {
    bool updateParent = true,
    bool emitEvent = true,
  }) {
    identifierControl.updateValue(
      value,
      updateParent: updateParent,
      emitEvent: emitEvent,
    );
  }

  void passwordValueUpdate(
    String value, {
    bool updateParent = true,
    bool emitEvent = true,
  }) {
    passwordControl.updateValue(
      value,
      updateParent: updateParent,
      emitEvent: emitEvent,
    );
  }

  void identifierValuePatch(
    String value, {
    bool updateParent = true,
    bool emitEvent = true,
  }) {
    identifierControl.patchValue(
      value,
      updateParent: updateParent,
      emitEvent: emitEvent,
    );
  }

  void passwordValuePatch(
    String value, {
    bool updateParent = true,
    bool emitEvent = true,
  }) {
    passwordControl.patchValue(
      value,
      updateParent: updateParent,
      emitEvent: emitEvent,
    );
  }

  void identifierValueReset(
    String value, {
    bool updateParent = true,
    bool emitEvent = true,
    bool removeFocus = false,
    bool? disabled,
  }) => identifierControl.reset(
    value: value,
    updateParent: updateParent,
    emitEvent: emitEvent,
    removeFocus: removeFocus,
    disabled: disabled,
  );

  void passwordValueReset(
    String value, {
    bool updateParent = true,
    bool emitEvent = true,
    bool removeFocus = false,
    bool? disabled,
  }) => passwordControl.reset(
    value: value,
    updateParent: updateParent,
    emitEvent: emitEvent,
    removeFocus: removeFocus,
    disabled: disabled,
  );

  FormControl<String> get identifierControl =>
      form.control(identifierControlPath()) as FormControl<String>;

  FormControl<String> get passwordControl =>
      form.control(passwordControlPath()) as FormControl<String>;

  void identifierSetDisabled(
    bool disabled, {
    bool updateParent = true,
    bool emitEvent = true,
  }) {
    if (disabled) {
      identifierControl.markAsDisabled(
        updateParent: updateParent,
        emitEvent: emitEvent,
      );
    } else {
      identifierControl.markAsEnabled(
        updateParent: updateParent,
        emitEvent: emitEvent,
      );
    }
  }

  void passwordSetDisabled(
    bool disabled, {
    bool updateParent = true,
    bool emitEvent = true,
  }) {
    if (disabled) {
      passwordControl.markAsDisabled(
        updateParent: updateParent,
        emitEvent: emitEvent,
      );
    } else {
      passwordControl.markAsEnabled(
        updateParent: updateParent,
        emitEvent: emitEvent,
      );
    }
  }

  @override
  Login get model {
    final isValid = !currentForm.hasErrors && currentForm.errors.isEmpty;

    if (!isValid) {
      _logLoginForm.warning(
        'Avoid calling `model` on invalid form.Possible exceptions for non-nullable fields which should be guarded by `required` validator.',
        null,
        StackTrace.current,
      );
    }
    return Login(identifier: _identifierValue, password: _passwordValue);
  }

  @override
  Login get rawModel {
    return Login(identifier: _identifierRawValue, password: _passwordRawValue);
  }

  @override
  void toggleDisabled({bool updateParent = true, bool emitEvent = true}) {
    final currentFormInstance = currentForm;

    if (currentFormInstance is! FormGroup) {
      return;
    }

    if (_disabled.isEmpty) {
      currentFormInstance.controls.forEach((key, control) {
        _disabled[key] = control.disabled;
      });

      currentForm.markAsDisabled(
        updateParent: updateParent,
        emitEvent: emitEvent,
      );
    } else {
      currentFormInstance.controls.forEach((key, control) {
        if (_disabled[key] == false) {
          currentFormInstance.controls[key]?.markAsEnabled(
            updateParent: updateParent,
            emitEvent: emitEvent,
          );
        }

        _disabled.remove(key);
      });
    }
  }

  @override
  bool equalsTo(Login? other) {
    final currentForm = this.currentForm;

    return const DeepCollectionEquality().equals(
      currentForm is FormControlCollection<dynamic>
          ? currentForm.rawValue
          : currentForm.value,
      LoginForm.formElements(other).rawValue,
    );
  }

  @override
  void submit({
    required void Function(Login model) onValid,
    void Function()? onNotValid,
  }) {
    currentForm.markAllAsTouched();
    if (currentForm.valid) {
      onValid(model);
    } else {
      _logLoginForm.info('Errors');
      _logLoginForm.info('┗━━ ${form.errors}');
      onNotValid?.call();
    }
  }

  AbstractControl<dynamic> get currentForm {
    return path == null ? form : form.control(path!);
  }

  @override
  void updateValue(
    Login? value, {
    bool updateParent = true,
    bool emitEvent = true,
  }) => form.updateValue(
    LoginForm.formElements(value).rawValue,
    updateParent: updateParent,
    emitEvent: emitEvent,
  );

  @override
  void reset({Login? value, bool updateParent = true, bool emitEvent = true}) =>
      form.reset(
        value: value != null ? formElements(value).rawValue : null,
        updateParent: updateParent,
        emitEvent: emitEvent,
      );

  String pathBuilder(String? pathItem) =>
      [path, pathItem].whereType<String>().join(".");

  static FormGroup formElements(Login? login) => FormGroup(
    {
      identifierControlName: FormControl<String>(
        value: login?.identifier,
        validators: [RequiredValidator()],
        asyncValidators: [],
        asyncValidatorsDebounceTime: 250,
        disabled: false,
        touched: false,
      ),
      passwordControlName: FormControl<String>(
        value: login?.password,
        validators: [RequiredValidator()],
        asyncValidators: [],
        asyncValidatorsDebounceTime: 250,
        disabled: false,
        touched: false,
      ),
    },
    validators: [],
    asyncValidators: [],
    asyncValidatorsDebounceTime: 250,
    disabled: false,
  );
}

class ReactiveLoginFormArrayBuilder<ReactiveLoginFormArrayBuilderT>
    extends StatelessWidget {
  const ReactiveLoginFormArrayBuilder({
    Key? key,
    this.control,
    this.formControl,
    this.builder,
    required this.itemBuilder,
    this.emptyBuilder,
    this.controlFilter,
  }) : assert(
         control != null || formControl != null,
         "You have to specify `control` or `formControl`!",
       ),
       super(key: key);

  final FormArray<ReactiveLoginFormArrayBuilderT>? formControl;

  final FormArray<ReactiveLoginFormArrayBuilderT>? Function(
    LoginForm formModel,
  )?
  control;

  final Widget Function(
    BuildContext context,
    List<Widget> itemList,
    LoginForm formModel,
  )?
  builder;

  final Widget Function(
    BuildContext context,
    int i,
    FormControl<ReactiveLoginFormArrayBuilderT> control,
    ReactiveLoginFormArrayBuilderT? item,
    LoginForm formModel,
  )
  itemBuilder;

  final Widget Function(BuildContext context)? emptyBuilder;

  final bool Function(FormControl<ReactiveLoginFormArrayBuilderT> control)?
  controlFilter;

  @override
  Widget build(BuildContext context) {
    return ReactiveFormArray<ReactiveLoginFormArrayBuilderT>(
      formArray: formControl ?? control?.call(ReactiveLoginForm.of(context)),
      builder: (context, formArray, child) {
        final values = formArray.controls.indexed
            .where(
              (e) =>
                  controlFilter?.call(
                    e.$2 as FormControl<ReactiveLoginFormArrayBuilderT>,
                  ) ??
                  true,
            )
            .toList();

        final itemList = values
            .map((item) {
              return MapEntry(
                item.$1,
                itemBuilder(
                  context,
                  item.$1,
                  formArray.controls[item.$1]
                      as FormControl<ReactiveLoginFormArrayBuilderT>,
                  item.$2.value,
                  formModel,
                ),
              );
            })
            .map((e) => e.value)
            .toList();

        if (emptyBuilder != null && itemList.isEmpty) {
          return emptyBuilder!(context);
        }

        return builder?.call(context, itemList, formModel) ??
            Column(children: itemList);
      },
    );
  }
}

class ReactiveLoginFormArrayBuilder2<ReactiveLoginFormArrayBuilderT>
    extends StatelessWidget {
  const ReactiveLoginFormArrayBuilder2({
    Key? key,
    this.control,
    this.formControl,
    this.builder,
    required this.itemBuilder,
    this.emptyBuilder,
    this.controlFilter,
  }) : assert(
         control != null || formControl != null,
         "You have to specify `control` or `formControl`!",
       ),
       super(key: key);

  final FormArray<ReactiveLoginFormArrayBuilderT>? formControl;

  final FormArray<ReactiveLoginFormArrayBuilderT>? Function(
    LoginForm formModel,
  )?
  control;

  final Widget Function(
    ({BuildContext context, List<Widget> itemList, LoginForm formModel}) params,
  )?
  builder;

  final Widget Function(
    ({
      BuildContext context,
      int i,
      FormControl<ReactiveLoginFormArrayBuilderT> control,
      ReactiveLoginFormArrayBuilderT? item,
      LoginForm formModel,
    })
    params,
  )
  itemBuilder;

  final Widget Function(BuildContext context)? emptyBuilder;

  final bool Function(FormControl<ReactiveLoginFormArrayBuilderT> control)?
  controlFilter;

  @override
  Widget build(BuildContext context) {
    return ReactiveFormArray<ReactiveLoginFormArrayBuilderT>(
      formArray: formControl ?? control?.call(ReactiveLoginForm.of(context)),
      builder: (context, formArray, child) {
        final values = formArray.controls.indexed
            .where(
              (e) =>
                  controlFilter?.call(
                    e.$2 as FormControl<ReactiveLoginFormArrayBuilderT>,
                  ) ??
                  true,
            )
            .toList();

        final itemList = values
            .map((item) {
              return MapEntry(
                item.$1,
                itemBuilder((
                  context: context,
                  i: item.$1,
                  control:
                      formArray.controls[item.$1]
                          as FormControl<ReactiveLoginFormArrayBuilderT>,
                  item: item.$2.value,
                  formModel: formModel,
                )),
              );
            })
            .map((e) => e.value)
            .toList();

        if (emptyBuilder != null && itemList.isEmpty) {
          return emptyBuilder!(context);
        }

        return builder?.call((
              context: context,
              itemList: itemList,
              formModel: formModel,
            )) ??
            Column(children: itemList);
      },
    );
  }
}

class ReactiveLoginFormFormGroupArrayBuilder<
  ReactiveLoginFormFormGroupArrayBuilderT
>
    extends StatelessWidget {
  const ReactiveLoginFormFormGroupArrayBuilder({
    Key? key,
    this.extended,
    this.getExtended,
    this.builder,
    required this.itemBuilder,
  }) : assert(
         extended != null || getExtended != null,
         "You have to specify `control` or `formControl`!",
       ),
       super(key: key);

  final ExtendedControl<
    List<Map<String, Object?>?>,
    List<ReactiveLoginFormFormGroupArrayBuilderT>
  >?
  extended;

  final ExtendedControl<
    List<Map<String, Object?>?>,
    List<ReactiveLoginFormFormGroupArrayBuilderT>
  >
  Function(LoginForm formModel)?
  getExtended;

  final Widget Function(
    BuildContext context,
    List<Widget> itemList,
    LoginForm formModel,
  )?
  builder;

  final Widget Function(
    BuildContext context,
    int i,
    ReactiveLoginFormFormGroupArrayBuilderT? item,
    LoginForm formModel,
  )
  itemBuilder;

  @override
  Widget build(BuildContext context) {
    final formModel = ReactiveLoginForm.of(context);

    if (formModel == null) {
      throw FormControlParentNotFoundException(this);
    }

    final value = (extended ?? getExtended?.call(formModel))!;

    return StreamBuilder<List<Map<String, Object?>?>?>(
      stream: value.control.valueChanges,
      builder: (context, snapshot) {
        final itemList =
            (value.value() ?? <ReactiveLoginFormFormGroupArrayBuilderT>[])
                .asMap()
                .map(
                  (i, item) =>
                      MapEntry(i, itemBuilder(context, i, item, formModel)),
                )
                .values
                .toList();

        return builder?.call(context, itemList, formModel) ??
            Column(children: itemList);
      },
    );
  }
}

[vasilich6107]

Hey @giboin @smithemely

check 8.0.1

[giboin]

Yes it's working well for me, thanks a lot!

[vasilich6107]

nice
closing the issue

[github-actions]

Hi @smithemely!
Your issue has been closed. If we were helpful don't forget to star the repo.

Please check our reactive_forms_widget package

We would appreciate sponsorship subscription or one time donation
https://github.com/sponsors/artflutter