defaultMapKeyValue function

dynamic defaultMapKeyValue({ required MapTypeInfo mapType, required Map currentEntries, List<Enum> keyEnumValues = const <Enum>[], })

Implementation

dynamic defaultMapKeyValue({
  required MapTypeInfo mapType,
  required Map<dynamic, dynamic> currentEntries,
  List<Enum> keyEnumValues = const <Enum>[],
}) {
  dynamic candidate = defaultValueFromTypeDescriptor(
    descriptor: mapType.keyTypeDescriptor,
    enumValues: keyEnumValues,
  );
  if (identical(candidate, unsupportedTypeDefaultValue)) {
    return unsupportedMapDefaultValue;
  }

  PrimitiveKind? primitiveKind = primitiveKindFromDescriptor(
    mapType.keyTypeDescriptor,
  );
  if (candidate == null && mapType.nullableKey) {
    if (primitiveKind != null) {
      candidate = defaultPrimitiveValue(primitiveKind);
    } else if (keyEnumValues.isNotEmpty) {
      candidate = keyEnumValues.first;
    } else {
      ListTypeInfo? nestedCollection = parseCollectionTypeDescriptor(
        mapType.keyTypeDescriptor,
      );
      if (nestedCollection != null) {
        candidate = materializeCollectionValue(
          nestedCollection,
          const <dynamic>[],
        );
      } else {
        MapTypeInfo? nestedMap = parseMapTypeDescriptor(
          mapType.keyTypeDescriptor,
        );
        if (nestedMap != null) {
          candidate = materializeMapValue(
            nestedMap,
            const <MapEntry<dynamic, dynamic>>[],
          );
        } else {
          $AClass? artifactClass = resolveArtifactTypeFromDescriptor(
            mapType.keyTypeDescriptor,
          );
          if (artifactClass != null) {
            candidate = artifactClass.construct();
          }
        }
      }
    }
  }

  if (primitiveKind == PrimitiveKind.string &&
      (candidate == null ||
          (candidate is String && candidate.trim().isEmpty))) {
    candidate = 'key1';
  }

  bool contains(dynamic key) {
    try {
      return currentEntries.containsKey(key);
    } catch (_) {
      return currentEntries.keys.any((existing) => existing == key);
    }
  }

  if (!contains(candidate)) {
    return candidate;
  }

  if (primitiveKind == PrimitiveKind.string) {
    String seed = candidate is String ? candidate.trim() : '';
    String base = seed.replaceFirst(RegExp(r'\d+$'), '');
    if (base.isEmpty) {
      base = 'key';
    }

    for (int i = 1; i < 100000; i++) {
      String next = '$base$i';
      if (!contains(next)) {
        return next;
      }
    }
    return unsupportedMapDefaultValue;
  }

  if (primitiveKind == PrimitiveKind.intType) {
    int next = candidate is int ? candidate : 0;
    for (int i = 0; i < 100000; i++) {
      if (!contains(next)) {
        return next;
      }
      next++;
    }
    return unsupportedMapDefaultValue;
  }

  if (primitiveKind == PrimitiveKind.doubleType) {
    double next = candidate is double ? candidate : 0.0;
    for (int i = 0; i < 100000; i++) {
      if (!contains(next)) {
        return next;
      }
      next += 1.0;
    }
    return unsupportedMapDefaultValue;
  }

  if (primitiveKind == PrimitiveKind.boolType) {
    if (!contains(false)) {
      return false;
    }
    if (!contains(true)) {
      return true;
    }
    return unsupportedMapDefaultValue;
  }

  if (primitiveKind == PrimitiveKind.dateTime) {
    DateTime next = candidate is DateTime ? candidate : DateTime.now();
    for (int i = 0; i < 100000; i++) {
      if (!contains(next)) {
        return next;
      }
      next = next.add(const Duration(milliseconds: 1));
    }
    return unsupportedMapDefaultValue;
  }

  if (keyEnumValues.isNotEmpty) {
    for (Enum option in keyEnumValues) {
      if (!contains(option)) {
        return option;
      }
    }
  }

  for (int i = 0; i < 16; i++) {
    dynamic generated = defaultValueFromTypeDescriptor(
      descriptor: mapType.keyTypeDescriptor,
      enumValues: keyEnumValues,
    );
    if (!identical(generated, unsupportedTypeDefaultValue) &&
        !contains(generated)) {
      return generated;
    }
  }

  return unsupportedMapDefaultValue;
}