feat: add converters for LogicalKeyboardKey and SingleActivator serialization

Author: helightdev

packages/dogs_flutter/lib/converters/various.dart

@@ -1,6 +1,8 @@
 import 'dart:ui';
 
 import 'package:dogs_core/dogs_core.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
 
 @linkSerializer
 class FlutterColorConverter extends SimpleDogConverter<Color> {
@@ -52,3 +54,80 @@ class FlutterColorConverter extends SimpleDogConverter<Color> {
     return "#${color.toARGB32().toRadixString(16).toUpperCase().padLeft(8, "0")}";
   }
 }
+
+@linkSerializer
+class FlutterLogicalKeyConverter extends SimpleDogConverter<LogicalKeyboardKey> {
+  FlutterLogicalKeyConverter() : super(serialName: "FLLogicalKey");
+
+  @override
+  LogicalKeyboardKey deserialize(value, DogEngine engine) {
+    if (value is Map) {
+      var keyId = value["id"];
+      var keyLabel = value["label"];
+      var resolved = LogicalKeyboardKey.findKeyByKeyId(keyId);
+      if (resolved != null && resolved.keyLabel == keyLabel) {
+        return resolved;
+      }
+    }
+    throw DogSerializerException(
+      message: "Invalid logical key value",
+      converter: this,
+    );
+  }
+
+  @override
+  serialize(LogicalKeyboardKey value, DogEngine engine) {
+    return {
+      "id": value.keyId,
+      "label": value.keyLabel,
+    };
+  }
+}
+
+@linkSerializer
+class FlutterSingleActivatorConverter
+    extends SimpleDogConverter<SingleActivator> {
+  FlutterSingleActivatorConverter() : super(serialName: "FLSingleActivator");
+
+  @override
+  SingleActivator deserialize(value, DogEngine engine) {
+    if (value is Map) {
+      var key = value["k"];
+      var control = value["c"] ?? false;
+      var shift = value["s"] ?? false;
+      var alt = value["a"] ?? false;
+      var meta = value["m"] ?? false;
+      var repeats = value["r"] ?? false;
+      var numLock = value["n"] ?? 0;
+
+      if (key is Map) {
+        return SingleActivator(
+          dogs.fromNative<LogicalKeyboardKey>(key),
+          control: control == true,
+          shift: shift == true,
+          alt: alt == true,
+          meta: meta == true,
+          numLock: LockState.values[numLock as int],
+          includeRepeats: repeats == true,
+        );
+      }
+    }
+    throw DogSerializerException(
+      message: "Invalid single activator value",
+      converter: this,
+    );
+  }
+
+  @override
+  serialize(SingleActivator value, DogEngine engine) {
+    return {
+      "k": engine.toNative<LogicalKeyboardKey>(value.trigger),
+      "c": value.control,
+      "s": value.shift,
+      "a": value.alt,
+      "m": value.meta,
+      "r": value.includeRepeats,
+      "n": value.numLock.index
+    };
+  }
+}

packages/dogs_flutter/lib/databinding/style.conv.g.dart

@@ -1,5 +1,7 @@
 import 'package:dogs_flutter/dogs_flutter.dart';
+import 'package:flutter/material.dart';
 import 'package:flutter/painting.dart';
+import 'package:flutter/services.dart';
 import 'package:flutter_test/flutter_test.dart';
 
 void main() {
@@ -66,5 +68,25 @@ void main() {
       final decoded = dogs.fromJson<Color>(encoded);
       expect(decoded, color);
     });
+
+    test("Serialize Logical Key", () {
+      final key = LogicalKeyboardKey.keyA;
+      final encoded = dogs.toJson<LogicalKeyboardKey>(key);
+      final decoded = dogs.fromJson<LogicalKeyboardKey>(encoded);
+      expect(decoded, key);
+    });
+
+    test("Serialize Single Activator", () {
+      var activator = SingleActivator(LogicalKeyboardKey.keyA, control: true, shift: true);
+      final encoded = dogs.toJson<SingleActivator>(activator);
+      final decoded = dogs.fromJson<SingleActivator>(encoded);
+      expect(decoded.trigger, activator.trigger);
+      expect(decoded.control, activator.control);
+      expect(decoded.shift, activator.shift);
+      expect(decoded.alt, activator.alt);
+      expect(decoded.meta, activator.meta);
+      expect(decoded.includeRepeats, activator.includeRepeats);
+      expect(decoded.numLock, activator.numLock);
+    });
   });
 }