Always write web view discriminators to JSON

WebViewProperties.fromJson picks the subclass from `webviewType`, and the
Google Maps and Twitter readers pick theirs from `mapMode` and `embedType`.
Each subclass sets these with a field initializer, which the defaults
builder took for a default, so toJson left them out and no version could
read a web view node back ("type 'Null' is not a subtype of type 'String'").

The builder no longer treats the initializer of a field that overrides a
supertype's field as a default. Only the web view discriminators change.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01YaHo5D7kD3eWcagvzh3o3K

Author: claude

lib/src/api/nodes/web_view_google_maps_properties.g.dart

@@ -0,0 +1,52 @@
+import 'dart:convert';
+
+import 'package:codelessly_api/codelessly_api.dart';
+import 'package:test/test.dart';
+
+Map<String, dynamic> webView(String id, Map<String, dynamic> properties) => {
+  'id': id,
+  'name': 'Web View',
+  'type': 'webView',
+  'basicBoxLocal': [0, 0, 300, 200],
+  'properties': properties,
+};
+
+void main() {
+  // WebViewProperties.fromJson picks the subclass from webviewType, and the
+  // Google Maps and Twitter readers pick theirs from mapMode and embedType,
+  // so these keys must be written even though each subclass has only one
+  // value for them.
+  final samples = {
+    'webpage': webView('page', {
+      'webviewType': 'webpage',
+      'pageSourceType': 'url',
+      'input': 'https://example.com',
+    }),
+    'googleMaps': webView('maps', {
+      'webviewType': 'googleMaps',
+      'mapMode': 'places',
+      'query': 'Coffee',
+      'url': 'https://maps.example.com',
+    }),
+    'twitter': webView('tweet', {
+      'webviewType': 'twitter',
+      'embedType': 'tweet',
+      'tweetURL': 'https://x.com/a/status/1',
+      'mediaAutoPlaybackPolicy': 'requireUserActionForAllMedia',
+    }),
+  };
+
+  for (final MapEntry(key: kind, value: input) in samples.entries) {
+    test('$kind web view writes its discriminators and reads back', () {
+      final node = NodeJsonConverter().fromJson(input)!;
+      final json = jsonDecode(jsonEncode(node.toJson())) as Map;
+      final properties = json['properties'] as Map;
+      expect(properties['webviewType'], kind);
+      if (kind == 'googleMaps') expect(properties['mapMode'], 'places');
+      if (kind == 'twitter') expect(properties['embedType'], 'tweet');
+
+      final back = NodeJsonConverter().fromJson(json)!;
+      expect(jsonDecode(jsonEncode(back.toJson())), json);
+    });
+  }
+}

lib/src/api/nodes/web_view_node.g.dart

@@ -13,7 +13,9 @@
 /// 4. The field's own initializer, if the field is set through that
 ///    constructor or is mutable, and the initializer is a constant-like
 ///    expression. A final field without a constructor parameter (such as a
-///    node's `type`) is always written.
+///    node's `type`) is always written, and so is a field that overrides a
+///    supertype's field (such as `webviewType` in a `WebViewProperties`
+///    subclass), because polymorphic readers pick the subclass from it.
 ///
 /// Fields annotated with `@JsonOmitIf(test)` are also removed when
 /// `test(instance)` is true.
@@ -97,7 +99,8 @@ class JsonDefaultsGenerator extends GeneratorForAnnotation<JsonSerializable> {
           _annotationArgument(declaration, 'JsonLegacyDefault') ??
           _jsonKeyDefaultValue(declaration) ??
           paramDefaults[name] ??
-          (paramNames.contains(name) || !field.isFinal
+          ((paramNames.contains(name) || !field.isFinal) &&
+                  !_overridesSuperField(field)
               ? _simpleInitializer(declaration)
               : null);
       if (defaultCode != null) {
@@ -121,6 +124,23 @@ ${checks.join('\n')}
 ''';
   }
 
+  /// Whether [field] overrides a field of a supertype of the class that
+  /// declares it, like `late WebViewType webviewType = WebViewType.webpage`
+  /// in a subclass of `WebViewProperties`.
+  ///
+  /// Such an initializer tells the subclasses apart rather than being a
+  /// default: polymorphic readers such as `WebViewProperties.fromJson` pick
+  /// the subclass from the key, so it must always be written.
+  bool _overridesSuperField(FieldElement field) {
+    final owner = field.enclosingElement;
+    if (owner is! InterfaceElement) return false;
+    return owner.allSupertypes.any(
+      (type) => type.element.fields.any(
+        (other) => !other.isStatic && other.name == field.name,
+      ),
+    );
+  }
+
   /// Public instance fields of [element] and its superclasses, closest first.
   Iterable<FieldElement> _serializableFields(ClassElement element) sync* {
     final classes = <InterfaceElement>[