Field Property Access #3

SaadArdati · BirjuVachhani · commit 8105f7bec688 · 2025-01-09T01:07:06.000+05:30
diff --git a/lib/src/api/field_access.dart b/lib/src/api/field_access.dart
@@ -0,0 +1,263 @@
+import 'dart:core';
+
+import '../../codelessly_api.dart';
+
+/// Signature for callbacks that report that an underlying value has changed.
+///
+/// See also:
+///
+///  * [ValueSetter], for callbacks that report that a value has been set.
+typedef ValueChanged<T> = void Function(T value);
+
+/// A utility class to access properties of a class.
+typedef GetterCallback<T extends Object?> = T Function();
+
+/// A callback that returns the default value of a property.
+typedef DefaultValueCallback<T> = T? Function();
+
+/// A callback that returns the options of a property.
+typedef FieldOptionsGetter<T> = Iterable<T> Function();
+
+mixin FieldsHolder {
+  Map<String, FieldAccess> get fields;
+
+// String get dynamicKeyType;
+}
+
+/// A class that provides extrinsic meta access to a field.
+// final class ExactFieldAccess<T extends Object?> extends FieldAccess<T, T> {
+//   /// Constructs an exact field access.
+//   const ExactFieldAccess(
+//     super.setter,
+//     super.getter, {
+//     super.defaultValue,
+//   });
+//
+//   /// Constructs an exact field access with options.
+//   const ExactFieldAccess.options(
+//     super.setter,
+//     super.getter, {
+//     required super.options,
+//     super.defaultValue,
+//   }) : super.options();
+// }
+
+/// A class that provides extrinsic meta access to a field.
+sealed class FieldAccess<GetValue extends Object?> {
+  final GetterCallback<String> label;
+
+  final GetterCallback<String> description;
+  final ValueChanged<GetValue> setter;
+
+  final GetterCallback<GetValue> _getter;
+
+  GetterCallback<GetValue> get getValue => _getter;
+
+  void setValue(Object? value);
+
+  final DefaultValueCallback<GetValue>? _defaultValue;
+
+  DefaultValueCallback<GetValue>? get getDefaultValue => _defaultValue;
+
+  dynamic get serialize;
+
+  String get dynamicKeyType;
+
+  Map<String, dynamic>? get supplementarySchema => null;
+
+  dynamic get schema => {
+        'type': dynamicKeyType,
+        'value': serialize,
+        if (getDefaultValue?.call() case Object defaultValue)
+          'default': defaultValue,
+        if (supplementarySchema case Map<String, dynamic> supplementary)
+          ...supplementary
+      };
+
+  /// Constructs a field access.
+  const FieldAccess(
+    this.label,
+    this.description,
+    this.setter,
+    this._getter, {
+    DefaultValueCallback<GetValue>? defaultValue,
+  }) : _defaultValue = defaultValue;
+}
+
+final class StringFieldAccess extends FieldAccess<String> {
+  const StringFieldAccess(
+    super.label,
+    super.description,
+    super.setter,
+    super.getter, {
+    super.defaultValue,
+  });
+
+  @override
+  String get dynamicKeyType => 'string';
+
+  @override
+  dynamic get serialize => getValue();
+
+  @override
+  void setValue(Object? value) => setter(value.typedValue<String>()!);
+}
+
+final class NumFieldAccess<Number extends num> extends FieldAccess<Number> {
+  const NumFieldAccess(
+    super.label,
+    super.description,
+    super.setter,
+    super.getter, {
+    this.min,
+    this.max,
+    super.defaultValue,
+  });
+
+  @override
+  String get dynamicKeyType => 'num';
+
+  @override
+  dynamic get serialize => getValue();
+
+  final GetterCallback<Number>? min;
+
+  final GetterCallback<Number>? max;
+
+  @override
+  Map<String, dynamic> get supplementarySchema => {
+        if (getValue() is double) 'fractionDigits': 2,
+        if (min case GetterCallback<Number> min) 'min': min(),
+        if (max case GetterCallback<Number> max) 'max': max(),
+      };
+
+  @override
+  void setValue(Object? value) => setter(value.typedValue<Number>()!);
+}
+
+final class BoolFieldAccess extends FieldAccess<bool> {
+  const BoolFieldAccess(
+    super.label,
+    super.description,
+    super.setter,
+    super.getter, {
+    super.defaultValue,
+  });
+
+  @override
+  dynamic get serialize => getValue();
+
+  @override
+  String get dynamicKeyType => 'bool';
+
+  @override
+  void setValue(Object? value) => setter(value.typedValue<bool>()!);
+}
+
+final class EnumFieldAccess<T extends Enum> extends FieldAccess<T> {
+  const EnumFieldAccess(
+    super.label,
+    super.description,
+    super.setter,
+    super.getter, {
+    required DefaultValueCallback<T>? defaultValue,
+    required FieldOptionsGetter<T> options,
+  })  : getOptions = options,
+        super(defaultValue: defaultValue);
+
+  final FieldOptionsGetter<T> getOptions;
+
+  @override
+  String get dynamicKeyType => 'options';
+
+  @override
+  dynamic get serialize => getValue().name;
+
+  @override
+  Map<String, dynamic> get supplementarySchema => {
+        'options': {
+          for (final T option in getOptions())
+            option.name: option.name.toUpperCase(),
+        }
+      };
+
+  @override
+  void setValue(Object? value) {
+    final Map<String, T> allValues = getOptions().asNameMap();
+    setter(allValues[value] ?? getDefaultValue!()!);
+  }
+}
+
+final class IterableFieldAccess<T extends List<Object?>>
+    extends FieldAccess<T> {
+  const IterableFieldAccess(
+    super.label,
+    super.description,
+    super.setter,
+    super.getter, {
+    super.defaultValue,
+  });
+
+  @override
+  String get dynamicKeyType => 'items';
+
+  @override
+  dynamic get serialize => [
+        for (final Object? item in getValue())
+          item is FieldAccess ? item.serialize : item,
+      ];
+
+  @override
+  Map<String, dynamic> get supplementarySchema => {
+        'items': [
+          for (final Object? item in getValue())
+            item is FieldAccess ? item.schema : item,
+        ],
+      };
+
+  @override
+  void setValue(Object? value) => setter(value as T);
+}
+
+final class ColorFieldAccess extends FieldAccess<ColorRGB?> {
+  ColorFieldAccess(
+    super.label,
+    super.description,
+    super.setter,
+    super.getter, {
+    super.defaultValue,
+  });
+
+  @override
+  String get dynamicKeyType => 'color';
+
+  @override
+  dynamic get serialize => getValue()?.toJson();
+
+  @override
+  Map<String, dynamic> get supplementarySchema => {
+        'pattern': r'^#(?:[0-9a-fA-F]{3}){1,2}$',
+      };
+
+  @override
+  void setValue(Object? value) => setter(value.typedValue<ColorRGB>());
+}
+
+final class RadiusFieldAccess extends FieldAccess<CornerRadius> {
+  RadiusFieldAccess(
+    super.label,
+    super.description,
+    super.setter,
+    super.getter, {
+    super.defaultValue,
+  });
+
+  @override
+  String get dynamicKeyType => 'radius';
+
+  @override
+  dynamic get serialize => getValue().toJson();
+
+  @override
+  void setValue(Object? value) => setter(value.typedValue<CornerRadius>()!);
+}
diff --git a/lib/src/api/mixins.dart b/lib/src/api/mixins.dart
@@ -3,7 +3,7 @@ import 'package:equatable/equatable.dart';
 import 'package:meta/meta.dart';
 
 import '../../codelessly_api.dart';
-import 'property_access.dart';
+import 'field_access.dart';
 
 /// Excludes [BoxConstraintsModel] from the json if it's technically doing
 /// nothing.
@@ -601,13 +601,17 @@ mixin GeometryMixin on BaseNode {
     required StrokeSide? strokeSide,
   }) {
     this.fills = fills;
-    fields['fills'] = ExactFieldAccess<List<PaintModel>>(
+    fields['fills'] = IterableFieldAccess<List<PaintModel>>(
+      () => 'Fills',
+      () => 'A list of fills applied to the node.',
       (value) => this.fills = value,
       () => this.fills,
     );
 
     this.strokes = strokes;
-    fields['strokes'] = ExactFieldAccess<List<PaintModel>>(
+    fields['strokes'] = IterableFieldAccess<List<PaintModel>>(
+      () => 'Strokes',
+      () => 'A list of strokes applied to the node.',
       (value) => this.strokes = value,
       () => this.strokes,
     );
@@ -735,12 +739,16 @@ mixin CornerMixin on BaseNode {
     required double cornerSmoothing,
   }) {
     this.cornerRadius = cornerRadius;
-    fields['cornerRadius'] = ExactFieldAccess<CornerRadius>(
+    fields['cornerRadius'] = RadiusFieldAccess(
+      () => 'Corner Radius',
+      () => 'Radius of the corners of the node.',
       (value) => this.cornerRadius = value,
       () => this.cornerRadius,
     );
     this.cornerSmoothing = cornerSmoothing;
-    fields['cornerSmoothing'] = ExactFieldAccess<double>(
+    fields['cornerSmoothing'] = NumFieldAccess<double>(
+      () => 'Corner Smoothing',
+      () => 'Level of pixel smoothing applied to the corners.',
       (value) => this.cornerSmoothing = value,
       () => this.cornerSmoothing,
     );
diff --git a/lib/src/api/models/paint.dart b/lib/src/api/models/paint.dart
@@ -4,7 +4,7 @@ import 'package:codelessly_json_annotation/codelessly_json_annotation.dart';
 import 'package:equatable/equatable.dart';
 
 import '../../../codelessly_api.dart';
-import '../property_access.dart';
+import '../field_access.dart';
 
 part 'paint.g.dart';
 
@@ -37,7 +37,7 @@ Object? _readId(Map json, String key) => json[key] ?? generateId();
 /// A solid color, gradient, or image texture that can be applied as fill or
 /// stroke.
 @JsonSerializable()
-class PaintModel with EquatableMixin, SerializableMixin, BagOfFieldsMixin {
+class PaintModel with EquatableMixin, SerializableMixin, FieldsHolder {
   /// identifier of this paint.
   @JsonKey(readValue: _readId)
   final String id;
@@ -174,22 +174,30 @@ class PaintModel with EquatableMixin, SerializableMixin, BagOfFieldsMixin {
   bool get hasImageSourceSize => sourceWidth != null && sourceHeight != null;
 
   late final Map<String, FieldAccess> _fields = {
-    'color': FieldAccess<ColorRGB?, Object?>(
-      (value) => color = value.typedValue<ColorRGB>(),
+    'color': ColorFieldAccess(
+      () => 'Color',
+      () => 'The color of the paint.',
+      (value) => color = value,
       () => color,
     ),
-    'blendMode': ExactFieldAccess<BlendModeC>.options(
+    'blendMode': EnumFieldAccess<BlendModeC>(
+      () => 'Blend Mode',
+      () => 'How this node blends with nodes behind it in the scene.',
       (value) => blendMode = value,
       () => blendMode,
       options: () => BlendModeC.values,
       defaultValue: () => BlendModeC.srcOver,
     ),
-    'opacity': FieldAccess<double, Object?>(
-      (value) => opacity = value.typedValue<double>()!,
+    'opacity': NumFieldAccess<double>(
+      () => 'Opacity',
+      () => 'The transparency of this layer.',
+      (value) => opacity = value,
       () => opacity,
     ),
-    'visible': FieldAccess<bool, Object?>(
-      (value) => visible = value.typedValue<bool>()!,
+    'visible': BoolFieldAccess(
+      () => 'Visible',
+      () => 'Whether this layer is visible or not.',
+      (value) => visible = value,
       () => visible,
     ),
   };
diff --git a/lib/src/api/nodes/base_node.dart b/lib/src/api/nodes/base_node.dart
@@ -7,10 +7,10 @@ import 'package:collection/collection.dart';
 import 'package:equatable/equatable.dart';
 
 import '../constants.dart';
+import '../field_access.dart';
 import '../math_helper.dart';
 import '../mixins.dart';
 import '../models/models.dart';
-import '../property_access.dart';
 import '../utils.dart';
 
 part '../node_processor.dart';
@@ -33,7 +33,7 @@ abstract class BaseNode
         EquatableMixin,
         VariablePropertiesMixin,
         ComponentMixin,
-        BagOfFieldsMixin {
+        FieldsHolder {
   /// [type] is a string representation for the type of this node. It is a
   /// unique key that this node class uses for static registration. It is
   /// usually the lowerCamelCase of the class' name. Overriding [type] is
diff --git a/lib/src/api/property_access.dart b/lib/src/api/property_access.dart
