Keep unlimited text field lines and empty text variables through JSON

TextFieldProperties.maxLines null (unlimited) was left out of toJson and read
back as the default of 1, so minLines 3 with unlimited max lines asserted at
runtime. An explicit null is now written and read back as null; designs
without the key keep reading as 1.

A text variable holding '' returned null from getValue(), so conditions like
x != '' were true. It now returns ''. A null value is stored as '' rather
than the string 'null'.

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

Author: claude

CHANGELOG.md

@@ -1,5 +1,9 @@
 ## Unreleased
 
+- `TextFieldProperties.maxLines`: `null` (unlimited lines) is written as an
+  explicit `null` and reads back as `null`; a missing key still reads as 1.
+- `VariableData.getValue()` returns an empty text variable as `''` instead of
+  `null`, and a `null` value is stored as `''` instead of `'null'`.
 - `AuthOperation.sendEmailVerification`, `updatePassword` and
   `deleteAccount`.
 - `DelayAction` (`ActionType.delay`): waits `milliseconds` before the next

lib/src/api/models/variables_model.dart

@@ -121,7 +121,7 @@ class VariableData
     Object? value = '',
     this.type = VariableType.text,
     Map<String, dynamic>? extra,
-  }) : value = sanitizeValueForVariableType(value, type).toString(),
+  }) : value = sanitizeValueForVariableType(value, type) ?? '',
        extra = extra ?? {};
 
   /// Duplicate a [VariableData] with the given parameters.
@@ -171,8 +171,11 @@ class VariableData
   );
 
   /// Returns the value converted to the appropriate type according to [type].
+  ///
+  /// A text variable returns its value as is, so one holding an empty string
+  /// stays an empty string and compares equal to `''` in conditions.
   Object? getValue() => switch (type) {
-    VariableType.text => value.isEmpty ? null : value,
+    VariableType.text => value,
     VariableType.image => value.isEmpty ? null : value,
     VariableType.integer => num.tryParse(value).toInt(),
     VariableType.decimal => num.tryParse(value).toDouble(),

lib/src/api/nodes/text_field_node.dart

@@ -202,7 +202,16 @@ class TextFieldProperties extends CustomProperties with FieldsHolder {
   int? maxLength;
 
   /// Maximum lines of text that appear at a time before the field becomes
-  /// scrollable.
+  /// scrollable. Null means unlimited: the field grows with its content.
+  ///
+  /// Stored JSON leaves the key out for the default of 1 and writes an
+  /// explicit `null` for unlimited, so both survive a round trip. Designs
+  /// saved before null was written have no key and keep reading as 1.
+  @JsonKey(
+    includeIfNull: true,
+    readValue: _readMaxLines,
+    fromJson: _maxLinesFromJson,
+  )
   int? maxLines;
 
   /// Maximum lines of text that appear at a time.
@@ -571,3 +580,18 @@ class TextFieldProperties extends CustomProperties with FieldsHolder {
     textInputAction,
   ];
 }
+
+/// Reads `maxLines`: a missing key is the default of 1, while an explicit
+/// `null` means unlimited lines.
+///
+/// An explicit null is passed on as [_unlimitedLines] because the generated
+/// reader replaces a null result with the constructor default of 1.
+Object? _readMaxLines(Map json, String key) =>
+    json.containsKey(key) ? (json[key] ?? _unlimitedLines) : 1;
+
+/// Converts what [_readMaxLines] returned into the field value.
+int? _maxLinesFromJson(Object? value) => value is num ? value.toInt() : null;
+
+/// Marks an explicit `null` (unlimited lines) between [_readMaxLines] and
+/// [_maxLinesFromJson].
+const String _unlimitedLines = 'unlimited';

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

@@ -0,0 +1,42 @@
+import 'dart:convert';
+
+import 'package:codelessly_api/codelessly_api.dart';
+import 'package:test/test.dart';
+
+TextFieldProperties roundTrip(TextFieldProperties properties) =>
+    TextFieldProperties.fromJson(jsonDecode(jsonEncode(properties.toJson())));
+
+void main() {
+  group('TextFieldProperties.maxLines', () {
+    test('default of 1 is left out and reads back as 1', () {
+      final properties = TextFieldProperties();
+      expect(properties.toJson().containsKey('maxLines'), isFalse);
+      expect(roundTrip(properties).maxLines, 1);
+    });
+
+    test('null (unlimited) is written and survives a round trip', () {
+      final properties = TextFieldProperties(maxLines: null, minLines: 3);
+      final json = properties.toJson();
+      expect(json.containsKey('maxLines'), isTrue);
+      expect(json['maxLines'], isNull);
+
+      final decoded = roundTrip(properties);
+      expect(decoded.maxLines, isNull);
+      expect(decoded.minLines, 3);
+    });
+
+    test('other values survive a round trip', () {
+      expect(roundTrip(TextFieldProperties(maxLines: 5)).maxLines, 5);
+    });
+
+    test('stored designs without the key keep reading as 1', () {
+      expect(TextFieldProperties.fromJson({}).maxLines, 1);
+      expect(TextFieldProperties.fromJson({'minLines': 3}).maxLines, 1);
+      expect(TextFieldProperties.fromJson({'maxLines': 4.0}).maxLines, 4);
+    });
+
+    test('an explicit null in stored JSON reads as unlimited', () {
+      expect(TextFieldProperties.fromJson({'maxLines': null}).maxLines, isNull);
+    });
+  });
+}

test/nodes/input/text_field_max_lines_test.dart

@@ -0,0 +1,52 @@
+import 'dart:convert';
+
+import 'package:codelessly_api/codelessly_api.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Empty text variables', () {
+    test('a text variable created with "" keeps "" as its value', () {
+      final variable = VariableData(id: 'a', name: 'x', value: '');
+      expect(variable.value, '');
+      expect(variable.getValue(), '');
+    });
+
+    test('"" survives a JSON round trip', () {
+      final variable = VariableData(id: 'a', name: 'x', value: '');
+      final decoded = VariableData.fromJson(
+        jsonDecode(jsonEncode(variable.toJson())),
+      );
+      expect(decoded.value, '');
+      expect(decoded.getValue(), '');
+    });
+
+    test('copyWith to "" keeps an empty string', () {
+      final variable = VariableData(id: 'a', name: 'x', value: 'hi');
+      expect(variable.copyWith(value: '').getValue(), '');
+    });
+
+    test('a null value is stored as "" rather than "null"', () {
+      final variable = VariableData(id: 'a', name: 'x', value: null);
+      expect(variable.value, '');
+      expect(variable.getValue(), '');
+      final number = VariableData(
+        id: 'b',
+        name: 'n',
+        value: 'abc',
+        type: VariableType.integer,
+      );
+      expect(number.value, '');
+      expect(number.getValue(), isNull);
+    });
+
+    test('an empty image variable still has no value', () {
+      final variable = VariableData(
+        id: 'a',
+        name: 'img',
+        value: '',
+        type: VariableType.image,
+      );
+      expect(variable.getValue(), isNull);
+    });
+  });
+}