maybeFromDynamic static method

JsonTextFormFieldBuilderModel? maybeFromDynamic(dynamic map, { Map<String, dynamic> args = const {}, JsonWidgetRegistry? registry, })

Implementation

static JsonTextFormFieldBuilderModel? maybeFromDynamic(
  dynamic map, {
  Map<String, dynamic> args = const {},
  JsonWidgetRegistry? registry,
}) {
  JsonTextFormFieldBuilderModel? result;

  if (map != null) {
    if (map is String) {
      map = yaon.parse(
        map,
        normalize: true,
      );
    }

    if (map is JsonTextFormFieldBuilderModel) {
      result = map;
    } else {
      registry ??= JsonWidgetRegistry.instance;
      map = registry.processArgs(map, <String>{}).value;
      result = JsonTextFormFieldBuilderModel(
        args,
        autocorrect: JsonClass.parseBool(
          map['autocorrect'],
          whenNull: true,
        ),
        autofillHints: map['autofillHints'],
        autofocus: JsonClass.parseBool(
          map['autofocus'],
          whenNull: false,
        ),
        autovalidateMode: () {
          dynamic parsed = ThemeDecoder.decodeAutovalidateMode(
            map['autovalidateMode'],
            validate: false,
          );

          return parsed;
        }(),
        buildCounter: map['buildCounter'],
        canRequestFocus: JsonClass.parseBool(
          map['canRequestFocus'],
          whenNull: true,
        ),
        clipBehavior: () {
          dynamic parsed = ThemeDecoder.decodeClip(
            map['clipBehavior'],
            validate: false,
          );
          parsed ??= Clip.hardEdge;

          return parsed;
        }(),
        contentInsertionConfiguration: map['contentInsertionConfiguration'],
        contextMenuBuilder: map['contextMenuBuilder'],
        controller: map['controller'],
        cursorColor: () {
          dynamic parsed = ThemeDecoder.decodeColor(
            map['cursorColor'],
            validate: false,
          );

          return parsed;
        }(),
        cursorHeight: () {
          dynamic parsed = JsonClass.maybeParseDouble(map['cursorHeight']);

          return parsed;
        }(),
        cursorOpacityAnimates: JsonClass.maybeParseBool(
          map['cursorOpacityAnimates'],
        ),
        cursorRadius: () {
          dynamic parsed = ThemeDecoder.decodeRadius(
            map['cursorRadius'],
            validate: false,
          );

          return parsed;
        }(),
        cursorWidth: () {
          dynamic parsed = JsonClass.maybeParseDouble(map['cursorWidth']);

          parsed ??= 2.0;

          return parsed;
        }(),
        decoration: map['decoration'],
        dragStartBehavior: () {
          dynamic parsed = ThemeDecoder.decodeDragStartBehavior(
            map['dragStartBehavior'],
            validate: false,
          );
          parsed ??= DragStartBehavior.start;

          return parsed;
        }(),
        enableIMEPersonalizedLearning: JsonClass.parseBool(
          map['enableIMEPersonalizedLearning'],
          whenNull: true,
        ),
        enableInteractiveSelection: JsonClass.maybeParseBool(
          map['enableInteractiveSelection'],
        ),
        enableSuggestions: JsonClass.parseBool(
          map['enableSuggestions'],
          whenNull: true,
        ),
        enabled: JsonClass.maybeParseBool(
          map['enabled'],
        ),
        expands: JsonClass.parseBool(
          map['expands'],
          whenNull: false,
        ),
        focusNode: map['focusNode'],
        initialValue: map['initialValue'],
        inputFormatters: map['inputFormatters'],
        keyboardAppearance: () {
          dynamic parsed = ThemeDecoder.decodeBrightness(
            map['keyboardAppearance'],
            validate: false,
          );

          return parsed;
        }(),
        keyboardType: () {
          dynamic parsed = ThemeDecoder.decodeTextInputType(
            map['keyboardType'],
            validate: false,
          );

          return parsed;
        }(),
        magnifierConfiguration: map['magnifierConfiguration'],
        maxLength: () {
          dynamic parsed = JsonClass.maybeParseInt(map['maxLength']);

          return parsed;
        }(),
        maxLengthEnforcement: () {
          dynamic parsed = ThemeDecoder.decodeMaxLengthEnforcement(
            map['maxLengthEnforcement'],
            validate: false,
          );

          return parsed;
        }(),
        maxLines: () {
          dynamic parsed = JsonClass.maybeParseInt(map['maxLines']);

          if (!map.containsKey('maxLines')) {
            parsed ??= 1;
          }

          return parsed;
        }(),
        minLines: () {
          dynamic parsed = JsonClass.maybeParseInt(map['minLines']);

          return parsed;
        }(),
        mouseCursor: () {
          dynamic parsed = ThemeDecoder.decodeMouseCursor(
            map['mouseCursor'],
            validate: false,
          );

          return parsed;
        }(),
        obscureText: JsonClass.parseBool(
          map['obscureText'],
          whenNull: false,
        ),
        obscuringCharacter: map['obscuringCharacter'] ?? '•',
        onAppPrivateCommand: map['onAppPrivateCommand'],
        onChanged: map['onChanged'],
        onEditingComplete: map['onEditingComplete'],
        onFieldSubmitted: map['onFieldSubmitted'],
        onSaved: map['onSaved'],
        onTap: map['onTap'],
        onTapOutside: map['onTapOutside'],
        readOnly: JsonClass.parseBool(
          map['readOnly'],
          whenNull: false,
        ),
        restorationId: map['restorationId'],
        scribbleEnabled: JsonClass.parseBool(
          map['scribbleEnabled'],
          whenNull: true,
        ),
        scrollController: map['scrollController'],
        scrollPadding: () {
          dynamic parsed = ThemeDecoder.decodeEdgeInsets(
            map['scrollPadding'],
            validate: false,
          );
          parsed ??= const EdgeInsets.all(20.0);

          return parsed;
        }(),
        scrollPhysics: () {
          dynamic parsed = ThemeDecoder.decodeScrollPhysics(
            map['scrollPhysics'],
            validate: false,
          );

          return parsed;
        }(),
        selectionControls: map['selectionControls'],
        selectionHeightStyle: () {
          dynamic parsed = ThemeDecoder.decodeBoxHeightStyle(
            map['selectionHeightStyle'],
            validate: false,
          );
          parsed ??= BoxHeightStyle.tight;

          return parsed;
        }(),
        selectionWidthStyle: () {
          dynamic parsed = ThemeDecoder.decodeBoxWidthStyle(
            map['selectionWidthStyle'],
            validate: false,
          );
          parsed ??= BoxWidthStyle.tight;

          return parsed;
        }(),
        showCursor: JsonClass.maybeParseBool(
          map['showCursor'],
        ),
        smartDashesType: () {
          dynamic parsed = ThemeDecoder.decodeSmartDashesType(
            map['smartDashesType'],
            validate: false,
          );

          return parsed;
        }(),
        smartQuotesType: () {
          dynamic parsed = ThemeDecoder.decodeSmartQuotesType(
            map['smartQuotesType'],
            validate: false,
          );

          return parsed;
        }(),
        spellCheckConfiguration: map['spellCheckConfiguration'],
        strutStyle: () {
          dynamic parsed = ThemeDecoder.decodeStrutStyle(
            map['strutStyle'],
            validate: false,
          );

          return parsed;
        }(),
        style: () {
          dynamic parsed = ThemeDecoder.decodeTextStyle(
            map['style'],
            validate: false,
          );

          return parsed;
        }(),
        textAlign: () {
          dynamic parsed = ThemeDecoder.decodeTextAlign(
            map['textAlign'],
            validate: false,
          );
          parsed ??= TextAlign.start;

          return parsed;
        }(),
        textAlignVertical: () {
          dynamic parsed = ThemeDecoder.decodeTextAlignVertical(
            map['textAlignVertical'],
            validate: false,
          );

          return parsed;
        }(),
        textCapitalization: () {
          dynamic parsed = ThemeDecoder.decodeTextCapitalization(
            map['textCapitalization'],
            validate: false,
          );
          parsed ??= TextCapitalization.none;

          return parsed;
        }(),
        textDirection: () {
          dynamic parsed = ThemeDecoder.decodeTextDirection(
            map['textDirection'],
            validate: false,
          );

          return parsed;
        }(),
        textInputAction: () {
          dynamic parsed = ThemeDecoder.decodeTextInputAction(
            map['textInputAction'],
            validate: false,
          );

          return parsed;
        }(),
        undoController: map['undoController'],
        validators: map['validators'],
      );
    }
  }

  return result;
}