@shopify/react-native-skia 0.1.171 → 0.1.173

package/cpp/rnskia/dom/props/ImageProps.h

@@ -25,8 +25,10 @@ static PropId PropNameFit = JsiPropId::get("fit");
 
 class ImageProp : public DerivedSkProp<SkImage> {
 public:
-  explicit ImageProp(PropId name) : DerivedSkProp<SkImage>() {
-    _imageProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit ImageProp(PropId name,
+                     const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedSkProp<SkImage>(onChange) {
+    _imageProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {
@@ -52,10 +54,11 @@ private:
 
 class ImageProps : public DerivedProp<FitRects> {
 public:
-  ImageProps() : DerivedProp<FitRects>() {
-    _fitProp = addProperty(std::make_shared<NodeProp>(PropNameFit));
-    _imageProp = addProperty(std::make_shared<ImageProp>(PropNameImage));
-    _rectProp = addProperty(std::make_shared<RectProps>(PropNameRect));
+  explicit ImageProps(const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<FitRects>(onChange) {
+    _fitProp = defineProperty<NodeProp>(PropNameFit);
+    _imageProp = defineProperty<ImageProp>(PropNameImage);
+    _rectProp = defineProperty<RectProps>(PropNameRect);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/LayerProp.h

@@ -10,9 +10,11 @@ namespace RNSkia {
 
 class LayerProp : public DerivedProp<SkPaint> {
 public:
-  explicit LayerProp(PropId name) : DerivedProp<SkPaint>() {
-    _layerPaintProp = addProperty(std::make_shared<PaintProp>(name));
-    _layerBoolProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit LayerProp(PropId name,
+                     const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkPaint>(onChange) {
+    _layerPaintProp = defineProperty<PaintProp>(name);
+    _layerBoolProp = defineProperty<NodeProp>(name);
   }
 
   /**
@@ -31,7 +33,7 @@ public:
 
     if (_layerPaintProp->isSet()) {
       // We have a paint object for the layer property
-      setDerivedValue(_layerPaintProp->getDerivedValue());
+      setDerivedValue(_layerPaintProp->getUnsafeDerivedValue());
       _isBool = false;
     } else {
       _isBool = false;

package/cpp/rnskia/dom/props/MatrixProp.h

@@ -11,8 +11,10 @@ static PropId PropNameMatrix = JsiPropId::get("matrix");
 
 class MatrixProp : public DerivedProp<SkMatrix> {
 public:
-  explicit MatrixProp(PropId name) : DerivedProp<SkMatrix>() {
-    _matrixProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit MatrixProp(PropId name,
+                      const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkMatrix>(onChange) {
+    _matrixProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/NumbersProp.h

@@ -11,8 +11,10 @@ namespace RNSkia {
 
 class NumbersProp : public DerivedProp<std::vector<SkScalar>> {
 public:
-  explicit NumbersProp(PropId name) : DerivedProp<std::vector<SkScalar>>() {
-    _positionProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit NumbersProp(PropId name,
+                       const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<std::vector<SkScalar>>(onChange) {
+    _positionProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {
@@ -36,8 +38,10 @@ private:
 
 class Numbers16Prop : public DerivedProp<std::vector<u_int16_t>> {
 public:
-  explicit Numbers16Prop(PropId name) : DerivedProp<std::vector<u_int16_t>>() {
-    _prop = addProperty(std::make_shared<NodeProp>(name));
+  explicit Numbers16Prop(PropId name,
+                         const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<std::vector<u_int16_t>>(onChange) {
+    _prop = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/PaintProps.h

@@ -21,11 +21,14 @@ namespace RNSkia {
 
 class PaintProp : public DerivedProp<SkPaint> {
 public:
-  explicit PaintProp(PropId name) : DerivedProp<SkPaint>() {
-    _paintProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit PaintProp(PropId name,
+                     const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkPaint>(onChange) {
+    _paintProp = defineProperty<NodeProp>(name);
   }
 
-  PaintProp() : PaintProp(JsiPropId::get("paint")) {}
+  explicit PaintProp(const std::function<void(BaseNodeProp *)> &onChange)
+      : PaintProp(JsiPropId::get("paint"), onChange) {}
 
   void updateDerivedValue() override {
     if (_paintProp->isSet()) {
@@ -50,108 +53,68 @@ private:
   NodeProp *_paintProp;
 };
 
-class PaintProps : public BaseDerivedProp {
+class PaintDrawingContextProp : public DerivedProp<DrawingContext> {
 public:
-  PaintProps() : BaseDerivedProp() {
-    _color = addProperty(std::make_shared<ColorProp>(JsiPropId::get("color")));
-    _style = addProperty(std::make_shared<NodeProp>(JsiPropId::get("style")));
-    _strokeWidth =
-        addProperty(std::make_shared<NodeProp>(JsiPropId::get("strokeWidth")));
-    _blendMode = addProperty(
-        std::make_shared<BlendModeProp>(JsiPropId::get("blendMode")));
-    _strokeJoin = addProperty(
-        std::make_shared<StrokeJoinProp>(JsiPropId::get("strokeJoin")));
-    _strokeCap = addProperty(
-        std::make_shared<StrokeCapProp>(JsiPropId::get("strokeCap")));
-    _strokeMiter =
-        addProperty(std::make_shared<NodeProp>(JsiPropId::get("strokeMiter")));
-    _antiAlias =
-        addProperty(std::make_shared<NodeProp>(JsiPropId::get("antiAlias")));
-    _opacity =
-        addProperty(std::make_shared<NodeProp>(JsiPropId::get("opacity")));
+  explicit PaintDrawingContextProp(
+      PropId name, const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<DrawingContext>(onChange) {
+    _paintProp = defineProperty<NodeProp>(name);
   }
 
-  void decorate(DrawingContext *context) {
-    // Now we can start updating the context
-
-    // Opacity
-    if (_opacity->isChanged() || context->isChanged()) {
-      auto parent = context->getParent();
-      auto paint = context->getMutablePaint();
-      if (_opacity->isSet()) {
-        auto currentOpacity = _opacity->value().getAsNumber();
-        auto parent = context->getParent();
-        if (parent != nullptr) {
-          currentOpacity *= parent->getPaint()->getAlphaf();
-        }
-        paint->setAlphaf(currentOpacity);
-      } else {
-        if (parent != nullptr) {
-          paint->setAlphaf(parent->getPaint()->getAlphaf());
+  explicit PaintDrawingContextProp(
+      const std::function<void(BaseNodeProp *)> &onChange)
+      : PaintDrawingContextProp(JsiPropId::get("paint"), onChange) {}
+
+  void updateDerivedValue() override {
+    if (_paintProp->isSet()) {
+      if (_paintProp->value().getType() == PropType::HostObject) {
+        // Read paint property as Host Object - JsiSkPaint
+        auto ptr = _paintProp->value().getAs<JsiSkPaint>();
+        if (ptr != nullptr) {
+          setDerivedValue(std::make_shared<DrawingContext>(ptr->getObject()));
         } else {
-          paint->setAlphaf(1.0);
+          throw std::runtime_error("Expected SkPaint object, got unknown "
+                                   "object when reading paint property.");
         }
+      } else {
+        setDerivedValue(nullptr);
       }
+    } else {
+      setDerivedValue(nullptr);
     }
+  }
 
-    // COLOR
-    if (_color->isSet() && (_color->isChanged() || context->isChanged())) {
-      auto paint = context->getMutablePaint();
-      auto opacity = paint->getAlphaf();
-      paint->setShader(nullptr);
-      paint->setColor(*_color->getDerivedValue());
-      paint->setAlphaf(opacity * paint->getColor4f().fA);
-    }
+private:
+  NodeProp *_paintProp;
+};
 
-    // Style
-    if (_style->isSet() && (_style->isChanged() || context->isChanged())) {
-      auto styleValue = _style->value().getAsString();
-      if (styleValue == "stroke") {
-        context->getMutablePaint()->setStyle(SkPaint::Style::kStroke_Style);
-      } else if (styleValue == "fill") {
-        context->getMutablePaint()->setStyle(SkPaint::Style::kFill_Style);
-      } else {
-        throw std::runtime_error(
-            styleValue + " is not a valud value for the style property.");
-      }
-    }
-    // Stroke Width
-    if (_strokeWidth->isSet() &&
-        (_strokeWidth->isChanged() || context->isChanged())) {
-      context->getMutablePaint()->setStrokeWidth(
-          _strokeWidth->value().getAsNumber());
-    }
-    // Blend mode
-    if (_blendMode->isSet() &&
-        (_blendMode->isChanged() || context->isChanged())) {
-      context->getMutablePaint()->setBlendMode(*_blendMode->getDerivedValue());
-    }
-    // Stroke Join
-    if (_strokeJoin->isSet() &&
-        (_strokeJoin->isChanged() || context->isChanged())) {
-      context->getMutablePaint()->setStrokeJoin(
-          *_strokeJoin->getDerivedValue());
-    }
-    // Stroke Cap
-    if (_strokeCap->isSet() &&
-        (_strokeCap->isChanged() || context->isChanged())) {
-      context->getMutablePaint()->setStrokeCap(*_strokeCap->getDerivedValue());
-    }
-    // Stroke Miter
-    if (_strokeMiter->isSet() &&
-        (_strokeMiter->isChanged() || context->isChanged())) {
-      context->getMutablePaint()->setStrokeMiter(
-          _strokeMiter->value().getAsNumber());
-    }
-    // AntiAlias
-    if (_antiAlias->isSet() &&
-        (_antiAlias->isChanged() || context->isChanged())) {
-      context->getMutablePaint()->setAntiAlias(_antiAlias->value().getAsBool());
-    }
+class PaintProps : public BaseDerivedProp {
+public:
+  explicit PaintProps(const std::function<void(BaseNodeProp *)> &onChange)
+      : BaseDerivedProp(onChange) {
+    _color = defineProperty<ColorProp>("color");
+    _style = defineProperty<NodeProp>("style");
+    _strokeWidth = defineProperty<NodeProp>("strokeWidth");
+    _blendMode = defineProperty<BlendModeProp>("blendMode");
+    _strokeJoin = defineProperty<StrokeJoinProp>("strokeJoin");
+    _strokeCap = defineProperty<StrokeCapProp>("strokeCap");
+    _strokeMiter = defineProperty<NodeProp>("strokeMiter");
+    _antiAlias = defineProperty<NodeProp>("antiAlias");
+    _opacity = defineProperty<NodeProp>("opacity");
   }
 
   void updateDerivedValue() override {}
 
+  ColorProp *getColor() { return _color; }
+  NodeProp *getStyle() { return _style; }
+  NodeProp *getStrokeWidth() { return _strokeWidth; }
+  BlendModeProp *getBlendMode() { return _blendMode; }
+  StrokeJoinProp *getStrokeJoin() { return _strokeJoin; }
+  StrokeCapProp *getStrokeCap() { return _strokeCap; }
+  NodeProp *getStrokeMiter() { return _strokeMiter; }
+  NodeProp *getAntiAlias() { return _antiAlias; }
+  NodeProp *getOpacity() { return _opacity; }
+
 private:
   ColorProp *_color;
   NodeProp *_style;

package/cpp/rnskia/dom/props/PathProp.h

@@ -16,8 +16,10 @@ namespace RNSkia {
 
 class PathProp : public DerivedProp<SkPath> {
 public:
-  explicit PathProp(PropId name) : DerivedProp<SkPath>() {
-    _pathProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit PathProp(PropId name,
+                    const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkPath>(onChange) {
+    _pathProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/PictureProp.h

@@ -11,8 +11,10 @@ namespace RNSkia {
 
 class PictureProp : public DerivedSkProp<SkPicture> {
 public:
-  explicit PictureProp(PropId name) : DerivedSkProp<SkPicture>() {
-    _pictureProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit PictureProp(PropId name,
+                       const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedSkProp<SkPicture>(onChange) {
+    _pictureProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/PointProp.h

@@ -20,8 +20,10 @@ static PropId PropNameY = JsiPropId::get("y");
 
 class PointProp : public DerivedProp<SkPoint> {
 public:
-  explicit PointProp(PropId name) : DerivedProp<SkPoint>() {
-    _pointProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit PointProp(PropId name,
+                     const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkPoint>(onChange) {
+    _pointProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/PointsProp.h

@@ -19,8 +19,10 @@ namespace RNSkia {
 
 class PointModeProp : public DerivedProp<SkCanvas::PointMode> {
 public:
-  explicit PointModeProp(PropId name) : DerivedProp<SkCanvas::PointMode>() {
-    _pointModeProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit PointModeProp(PropId name,
+                         const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkCanvas::PointMode>(onChange) {
+    _pointModeProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {
@@ -51,8 +53,10 @@ private:
 
 class PointsProp : public DerivedProp<std::vector<SkPoint>> {
 public:
-  explicit PointsProp(PropId name) : DerivedProp<std::vector<SkPoint>>() {
-    _pointsProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit PointsProp(PropId name,
+                      const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<std::vector<SkPoint>>(onChange) {
+    _pointsProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/RRectProp.h

@@ -27,8 +27,10 @@ static PropId PropNameR = JsiPropId::get("r");
  */
 class RRectProp : public DerivedProp<SkRRect> {
 public:
-  explicit RRectProp(PropId name) : DerivedProp() {
-    _prop = addProperty(std::make_shared<NodeProp>(name));
+  explicit RRectProp(PropId name,
+                     const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp(onChange) {
+    _prop = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {
@@ -78,12 +80,14 @@ private:
  */
 class RRectPropFromProps : public DerivedProp<SkRRect> {
 public:
-  RRectPropFromProps() : DerivedProp<SkRRect>() {
-    _x = addProperty(std::make_shared<NodeProp>(PropNameX));
-    _y = addProperty(std::make_shared<NodeProp>(PropNameY));
-    _width = addProperty(std::make_shared<NodeProp>(PropNameWidth));
-    _height = addProperty(std::make_shared<NodeProp>(PropNameHeight));
-    _r = addProperty(std::make_shared<NodeProp>(PropNameR));
+  explicit RRectPropFromProps(
+      const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkRRect>(onChange) {
+    _x = defineProperty<NodeProp>(PropNameX);
+    _y = defineProperty<NodeProp>(PropNameY);
+    _width = defineProperty<NodeProp>(PropNameWidth);
+    _height = defineProperty<NodeProp>(PropNameHeight);
+    _r = defineProperty<NodeProp>(PropNameR);
   }
 
   void updateDerivedValue() override {
@@ -111,17 +115,18 @@ private:
  */
 class RRectProps : public DerivedProp<SkRRect> {
 public:
-  explicit RRectProps(PropId name) : DerivedProp<SkRRect>() {
-    _rectProp = addProperty<RRectProp>(std::make_shared<RRectProp>(name));
-    _rectPropFromProps =
-        addProperty<RRectPropFromProps>(std::make_shared<RRectPropFromProps>());
+  explicit RRectProps(PropId name,
+                      const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkRRect>(onChange) {
+    _rectProp = defineProperty<RRectProp>(name);
+    _rectPropFromProps = defineProperty<RRectPropFromProps>();
   }
 
   void updateDerivedValue() override {
     if (_rectProp->isSet()) {
-      setDerivedValue(_rectProp->getDerivedValue());
+      setDerivedValue(_rectProp->getUnsafeDerivedValue());
     } else if (_rectPropFromProps->isSet()) {
-      setDerivedValue(_rectPropFromProps->getDerivedValue());
+      setDerivedValue(_rectPropFromProps->getUnsafeDerivedValue());
     } else {
       setDerivedValue(nullptr);
     }
@@ -138,8 +143,10 @@ private:
  */
 class BoxProps : public DerivedProp<SkRRect> {
 public:
-  explicit BoxProps(PropId name) : DerivedProp<SkRRect>() {
-    _boxProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit BoxProps(PropId name,
+                    const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkRRect>(onChange) {
+    _boxProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/RadiusProp.h

@@ -16,8 +16,10 @@ namespace RNSkia {
 
 class RadiusProp : public DerivedProp<SkPoint> {
 public:
-  explicit RadiusProp(PropId name) : DerivedProp<SkPoint>() {
-    _radiusProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit RadiusProp(PropId name,
+                      const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkPoint>(onChange) {
+    _radiusProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/RectProp.h

@@ -25,8 +25,10 @@ static PropId PropNameHeight = JsiPropId::get("height");
  */
 class RectProp : public DerivedProp<SkRect> {
 public:
-  explicit RectProp(PropId name) : DerivedProp() {
-    _prop = addProperty(std::make_shared<NodeProp>(name));
+  explicit RectProp(PropId name,
+                    const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp(onChange) {
+    _prop = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {
@@ -68,11 +70,13 @@ private:
  */
 class RectPropFromProps : public DerivedProp<SkRect> {
 public:
-  RectPropFromProps() : DerivedProp<SkRect>() {
-    _x = addProperty(std::make_shared<NodeProp>(PropNameX));
-    _y = addProperty(std::make_shared<NodeProp>(PropNameY));
-    _width = addProperty(std::make_shared<NodeProp>(PropNameWidth));
-    _height = addProperty(std::make_shared<NodeProp>(PropNameHeight));
+  explicit RectPropFromProps(
+      const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkRect>(onChange) {
+    _x = defineProperty<NodeProp>(PropNameX);
+    _y = defineProperty<NodeProp>(PropNameY);
+    _width = defineProperty<NodeProp>(PropNameWidth);
+    _height = defineProperty<NodeProp>(PropNameHeight);
   }
 
   void updateDerivedValue() override {
@@ -103,16 +107,18 @@ private:
  */
 class RectProps : public DerivedProp<SkRect> {
 public:
-  explicit RectProps(PropId name) : DerivedProp<SkRect>() {
-    _rectProp = addProperty(std::make_shared<RectProp>(name));
-    _rectPropFromProps = addProperty(std::make_shared<RectPropFromProps>());
+  explicit RectProps(PropId name,
+                     const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkRect>(onChange) {
+    _rectProp = defineProperty<RectProp>(name);
+    _rectPropFromProps = defineProperty<RectPropFromProps>();
   }
 
   void updateDerivedValue() override {
     if (_rectProp->isSet()) {
-      setDerivedValue(_rectProp->getDerivedValue());
+      setDerivedValue(_rectProp->getUnsafeDerivedValue());
     } else if (_rectPropFromProps->isSet()) {
-      setDerivedValue(_rectPropFromProps->getDerivedValue());
+      setDerivedValue(_rectPropFromProps->getUnsafeDerivedValue());
     } else {
       setDerivedValue(nullptr);
     }

package/cpp/rnskia/dom/props/StrokeProps.h

@@ -16,8 +16,10 @@ namespace RNSkia {
 
 class StrokeCapProp : public DerivedProp<SkPaint::Cap> {
 public:
-  explicit StrokeCapProp(PropId name) : DerivedProp<SkPaint::Cap>() {
-    _strokeCap = addProperty(std::make_shared<NodeProp>(name));
+  explicit StrokeCapProp(PropId name,
+                         const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkPaint::Cap>(onChange) {
+    _strokeCap = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {
@@ -45,8 +47,10 @@ private:
 
 class StrokeJoinProp : public DerivedProp<SkPaint::Join> {
 public:
-  explicit StrokeJoinProp(PropId name) : DerivedProp<SkPaint::Join>() {
-    _strokeJoin = addProperty(std::make_shared<NodeProp>(name));
+  explicit StrokeJoinProp(PropId name,
+                          const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkPaint::Join>(onChange) {
+    _strokeJoin = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/SvgProp.h

@@ -10,8 +10,10 @@ namespace RNSkia {
 
 class SvgProp : public DerivedSkProp<SkSVGDOM> {
 public:
-  explicit SvgProp(PropId name) : DerivedSkProp<SkSVGDOM>() {
-    _imageSvgProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit SvgProp(PropId name,
+                   const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedSkProp<SkSVGDOM>(onChange) {
+    _imageSvgProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/TextBlobProp.h

@@ -12,8 +12,10 @@ namespace RNSkia {
 
 class TextBlobProp : public DerivedSkProp<SkTextBlob> {
 public:
-  explicit TextBlobProp(PropId name) : DerivedSkProp<SkTextBlob>() {
-    _textBlobProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit TextBlobProp(PropId name,
+                        const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedSkProp<SkTextBlob>(onChange) {
+    _textBlobProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {
@@ -37,12 +39,12 @@ private:
 
 class TextPathBlobProp : public DerivedSkProp<SkTextBlob> {
 public:
-  TextPathBlobProp() : DerivedSkProp<SkTextBlob>() {
-    _fontProp = addProperty(std::make_shared<FontProp>(JsiPropId::get("font")));
-    _textProp = addProperty(std::make_shared<NodeProp>(JsiPropId::get("text")));
-    _pathProp = addProperty(std::make_shared<PathProp>(JsiPropId::get("path")));
-    _offsetProp = addProperty(
-        std::make_shared<NodeProp>(JsiPropId::get("initialOffset")));
+  explicit TextPathBlobProp(const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedSkProp<SkTextBlob>(onChange) {
+    _fontProp = defineProperty<FontProp>("font");
+    _textProp = defineProperty<NodeProp>("text");
+    _pathProp = defineProperty<PathProp>("path");
+    _offsetProp = defineProperty<NodeProp>("initialOffset");
 
     _fontProp->require();
     _textProp->require();

package/cpp/rnskia/dom/props/TileModeProp.h

@@ -16,8 +16,10 @@ namespace RNSkia {
 
 class TileModeProp : public DerivedProp<SkTileMode> {
 public:
-  explicit TileModeProp(PropId name) : DerivedProp<SkTileMode>() {
-    _tileModeProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit TileModeProp(PropId name,
+                        const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkTileMode>(onChange) {
+    _tileModeProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/TransformProp.h

@@ -20,8 +20,10 @@ static PropId PropNameRotateZ = JsiPropId::get("rotateZ");
 
 class TransformProp : public DerivedProp<SkMatrix> {
 public:
-  explicit TransformProp(PropId name) : DerivedProp<SkMatrix>() {
-    _transformProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit TransformProp(PropId name,
+                         const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkMatrix>(onChange) {
+    _transformProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/TransformsProps.h

@@ -12,13 +12,11 @@ namespace RNSkia {
 
 class TransformsProps : public DerivedProp<SkMatrix> {
 public:
-  TransformsProps() : DerivedProp<SkMatrix>() {
-    _transformProp = addProperty(
-        std::make_shared<TransformProp>(JsiPropId::get("transform")));
-    _originProp =
-        addProperty(std::make_shared<PointProp>(JsiPropId::get("origin")));
-    _matrixProp =
-        addProperty(std::make_shared<MatrixProp>(JsiPropId::get("matrix")));
+  explicit TransformsProps(const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkMatrix>(onChange) {
+    _transformProp = defineProperty<TransformProp>("transform");
+    _originProp = defineProperty<PointProp>("origin");
+    _matrixProp = defineProperty<MatrixProp>("matrix");
   }
 
   void updateDerivedValue() override {

package/cpp/rnskia/dom/props/UniformsProp.h

@@ -80,8 +80,10 @@ void processUniform(std::vector<SkScalar> &values, SkRuntimeEffect *source,
 
 class UniformsProp : public DerivedSkProp<SkData> {
 public:
-  UniformsProp(PropId name, NodeProp *sourceProp) : DerivedSkProp<SkData>() {
-    _uniformsProp = addProperty(std::make_shared<NodeProp>(name));
+  UniformsProp(PropId name, NodeProp *sourceProp,
+               const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedSkProp<SkData>(onChange) {
+    _uniformsProp = defineProperty<NodeProp>(name);
     _sourceProp = sourceProp;
   }
 

package/cpp/rnskia/dom/props/VertexModeProp.h

@@ -16,8 +16,10 @@ namespace RNSkia {
 
 class VertexModeProp : public DerivedProp<SkVertices::VertexMode> {
 public:
-  explicit VertexModeProp(PropId name) : DerivedProp<SkVertices::VertexMode>() {
-    _vertexModeProp = addProperty(std::make_shared<NodeProp>(name));
+  explicit VertexModeProp(PropId name,
+                          const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<SkVertices::VertexMode>(onChange) {
+    _vertexModeProp = defineProperty<NodeProp>(name);
   }
 
   void updateDerivedValue() override {