@shopify/react-native-skia 1.11.1 → 1.11.2

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

@@ -1,54 +0,0 @@
-#pragma once
-
-#include "DerivedNodeProp.h"
-#include "JsiSkMatrix.h"
-
-#include <memory>
-
-namespace RNSkia {
-
-static PropId PropNameMatrix = JsiPropId::get("matrix");
-
-class MatrixProp : public DerivedProp<SkMatrix> {
-public:
-  explicit MatrixProp(PropId name,
-                      const std::function<void(BaseNodeProp *)> &onChange)
-      : DerivedProp<SkMatrix>(onChange) {
-    _matrixProp = defineProperty<NodeProp>(name);
-  }
-
-  void updateDerivedValue() override {
-    if (_matrixProp->isSet() &&
-        _matrixProp->value().getType() == PropType::HostObject) {
-      // Try reading as SkMatrix
-      auto matrix = _matrixProp->value().getAs<JsiSkMatrix>();
-      if (matrix != nullptr) {
-        setDerivedValue(matrix->getObject());
-      }
-    } else if (_matrixProp->isSet()) {
-      auto values = _matrixProp->value().getAsArray();
-      auto m3 = std::make_shared<SkMatrix>();
-      if (values.size() == 9) {
-        for (size_t i = 0; i < values.size(); ++i) {
-          auto a = values[i];
-          m3->set(i, a.getAsNumber());
-        }
-      } else {
-        SkM44 m4;
-        for (size_t i = 0; i < values.size(); ++i) {
-          auto obj = values[i];
-          m4.setRC(i / 4, i % 4, obj.getAsNumber());
-        }
-        auto m = m4.asM33();
-        m3->setAll(m.rc(0, 0), m.rc(0, 1), m.rc(0, 2), m.rc(1, 0), m.rc(1, 1),
-                   m.rc(1, 2), m.rc(2, 0), m.rc(2, 1), m.rc(2, 2));
-      }
-      setDerivedValue(m3);
-    }
-  }
-
-private:
-  NodeProp *_matrixProp;
-};
-
-} // namespace RNSkia

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

@@ -1,67 +0,0 @@
-#pragma once
-
-#include "DerivedNodeProp.h"
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace RNSkia {
-
-class NumbersProp : public DerivedProp<std::vector<SkScalar>> {
-public:
-  explicit NumbersProp(PropId name,
-                       const std::function<void(BaseNodeProp *)> &onChange)
-      : DerivedProp<std::vector<SkScalar>>(onChange) {
-    _positionProp = defineProperty<NodeProp>(name);
-  }
-
-  void updateDerivedValue() override {
-    if (_positionProp->isSet()) {
-      auto positions = _positionProp->value().getAsArray();
-      std::vector<SkScalar> derivedPositions;
-      derivedPositions.reserve(positions.size());
-
-      for (size_t i = 0; i < positions.size(); ++i) {
-        derivedPositions.push_back(positions[i].getAsNumber());
-      }
-      setDerivedValue(std::move(derivedPositions));
-    } else {
-      setDerivedValue(nullptr);
-    }
-  }
-
-private:
-  NodeProp *_positionProp;
-};
-
-class Numbers16Prop : public DerivedProp<std::vector<u_int16_t>> {
-public:
-  explicit Numbers16Prop(PropId name,
-                         const std::function<void(BaseNodeProp *)> &onChange)
-      : DerivedProp<std::vector<u_int16_t>>(onChange) {
-    _prop = defineProperty<NodeProp>(name);
-  }
-
-  void updateDerivedValue() override {
-    if (_prop->isSet()) {
-      auto positions = _prop->value().getAsArray();
-      std::vector<u_int16_t> derivedPositions;
-      derivedPositions.reserve(positions.size());
-
-      for (size_t i = 0; i < positions.size(); ++i) {
-        derivedPositions.push_back(
-            static_cast<u_int16_t>(positions[i].getAsNumber()));
-      }
-      setDerivedValue(std::move(derivedPositions));
-    } else {
-      setDerivedValue(nullptr);
-    }
-  }
-
-private:
-  NodeProp *_prop;
-};
-
-} // namespace RNSkia

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

@@ -1,133 +0,0 @@
-#pragma once
-
-#include "BlendModeProp.h"
-#include "ColorProp.h"
-#include "NodeProp.h"
-#include "StrokeProps.h"
-
-#include "JsiSkPaint.h"
-#include "third_party/CSSColorParser.h"
-
-#include <memory>
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#include "include/core/SkPaint.h"
-
-#pragma clang diagnostic pop
-
-namespace RNSkia {
-
-class PaintProp : public DerivedProp<SkPaint> {
-public:
-  explicit PaintProp(PropId name,
-                     const std::function<void(BaseNodeProp *)> &onChange)
-      : DerivedProp<SkPaint>(onChange) {
-    _paintProp = defineProperty<NodeProp>(name);
-  }
-
-  explicit PaintProp(const std::function<void(BaseNodeProp *)> &onChange)
-      : PaintProp(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(ptr->getObject());
-        } else {
-          throw std::runtime_error("Expected SkPaint object, got unknown "
-                                   "object when reading paint property.");
-        }
-      } else {
-        setDerivedValue(nullptr);
-      }
-    } else {
-      setDerivedValue(nullptr);
-    }
-  }
-
-private:
-  NodeProp *_paintProp;
-};
-
-class PaintDrawingContextProp : public DerivedProp<DrawingContext> {
-public:
-  explicit PaintDrawingContextProp(
-      PropId name, const std::function<void(BaseNodeProp *)> &onChange)
-      : DerivedProp<DrawingContext>(onChange) {
-    _paintProp = defineProperty<NodeProp>(name);
-  }
-
-  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 {
-          throw std::runtime_error("Expected SkPaint object, got unknown "
-                                   "object when reading paint property.");
-        }
-      } else {
-        setDerivedValue(nullptr);
-      }
-    } else {
-      setDerivedValue(nullptr);
-    }
-  }
-
-private:
-  NodeProp *_paintProp;
-};
-
-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");
-    _dither = defineProperty<NodeProp>("dither");
-    _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 *getDither() { return _dither; }
-  NodeProp *getOpacity() { return _opacity; }
-
-private:
-  ColorProp *_color;
-  NodeProp *_style;
-  NodeProp *_strokeWidth;
-  BlendModeProp *_blendMode;
-  StrokeJoinProp *_strokeJoin;
-  StrokeCapProp *_strokeCap;
-  NodeProp *_strokeMiter;
-  NodeProp *_antiAlias;
-  NodeProp *_dither;
-  NodeProp *_opacity;
-};
-
-} // namespace RNSkia

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

@@ -1,45 +0,0 @@
-#pragma once
-
-#include "DerivedNodeProp.h"
-
-#include "JsiSkParagraph.h"
-
-#include <memory>
-#include <string>
-
-namespace RNSkia {
-
-class ParagraphProp : public DerivedProp<para::Paragraph *> {
-public:
-  explicit ParagraphProp(PropId name,
-                         const std::function<void(BaseNodeProp *)> &onChange)
-      : DerivedProp<para::Paragraph *>(onChange) {
-    _paragraphProp = defineProperty<NodeProp>(name);
-  }
-
-  void updateDerivedValue() override {
-    if (_paragraphProp->isSet()) {
-      if (_paragraphProp->value().getType() != PropType::HostObject) {
-        throw std::runtime_error("Expected Paragraph object for the " +
-                                 std::string(getName()) + " property.");
-      }
-
-      auto ptr = std::dynamic_pointer_cast<JsiSkParagraph>(
-          _paragraphProp->value().getAsHostObject());
-
-      if (ptr == nullptr) {
-        throw std::runtime_error("Expected paragraph object for the " +
-                                 std::string(getName()) + " property.");
-      }
-
-      setDerivedValue(ptr->getParagraph());
-    } else {
-      setDerivedValue(nullptr);
-    }
-  }
-
-private:
-  NodeProp *_paragraphProp;
-};
-
-} // namespace RNSkia

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

@@ -1,59 +0,0 @@
-#pragma once
-
-#include "DerivedNodeProp.h"
-#include "JsiSkPath.h"
-
-#include <memory>
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#include "include/core/SkPath.h"
-
-#pragma clang diagnostic pop
-
-namespace RNSkia {
-
-class PathProp : public DerivedProp<SkPath> {
-public:
-  explicit PathProp(PropId name,
-                    const std::function<void(BaseNodeProp *)> &onChange)
-      : DerivedProp<SkPath>(onChange) {
-    _pathProp = defineProperty<NodeProp>(name);
-  }
-
-  static std::shared_ptr<SkPath> processPath(const JsiValue &value) {
-    if (value.getType() == PropType::HostObject) {
-      // Try reading as Path
-      auto ptr = std::dynamic_pointer_cast<JsiSkPath>(value.getAsHostObject());
-      if (ptr != nullptr) {
-        return ptr->getObject();
-      }
-    } else if (value.getType() == PropType::String) {
-      // Read as string
-      auto pathString = value.getAsString();
-      SkPath result;
-
-      if (SkParsePath::FromSVGString(pathString.c_str(), &result)) {
-        return std::make_shared<SkPath>(result);
-      } else {
-        throw std::runtime_error("Could not parse path from string.");
-      }
-    }
-    return nullptr;
-  }
-
-  void updateDerivedValue() override {
-    if (!_pathProp->isSet()) {
-      setDerivedValue(nullptr);
-      return;
-    }
-    auto value = _pathProp->value();
-    setDerivedValue(PathProp::processPath(value));
-  }
-
-private:
-  NodeProp *_pathProp;
-};
-
-} // namespace RNSkia

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

@@ -1,40 +0,0 @@
-#pragma once
-
-#include "DerivedNodeProp.h"
-
-#include "JsiSkPicture.h"
-
-#include <memory>
-#include <string>
-
-namespace RNSkia {
-
-class PictureProp : public DerivedSkProp<SkPicture> {
-public:
-  explicit PictureProp(PropId name,
-                       const std::function<void(BaseNodeProp *)> &onChange)
-      : DerivedSkProp<SkPicture>(onChange) {
-    _pictureProp = defineProperty<NodeProp>(name);
-  }
-
-  void updateDerivedValue() override {
-    if (_pictureProp->value().getType() != PropType::HostObject) {
-      throw std::runtime_error("Expected SkPicture object for the " +
-                               std::string(getName()) + " property.");
-    }
-
-    auto ptr = std::dynamic_pointer_cast<JsiSkPicture>(
-        _pictureProp->value().getAsHostObject());
-    if (ptr == nullptr) {
-      throw std::runtime_error("Expected SkPicture object for the " +
-                               std::string(getName()) + " property.");
-    }
-
-    setDerivedValue(ptr->getObject());
-  }
-
-private:
-  NodeProp *_pictureProp;
-};
-
-} // namespace RNSkia

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

@@ -1,65 +0,0 @@
-#pragma once
-
-#include "DerivedNodeProp.h"
-#include "JsiSkPoint.h"
-
-#include <memory>
-#include <utility>
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#include "include/core/SkPoint.h"
-
-#pragma clang diagnostic pop
-
-namespace RNSkia {
-
-static PropId PropNameX = JsiPropId::get("x");
-static PropId PropNameY = JsiPropId::get("y");
-
-class PointProp : public DerivedProp<SkPoint> {
-public:
-  explicit PointProp(PropId name,
-                     const std::function<void(BaseNodeProp *)> &onChange)
-      : DerivedProp<SkPoint>(onChange) {
-    _pointProp = defineProperty<NodeProp>(name);
-  }
-
-  void updateDerivedValue() override {
-    if (_pointProp->isSet()) {
-      // Check for JsiSkRect and JsiSkPoint
-      setDerivedValue(processValue(_pointProp->value()));
-    } else {
-      setDerivedValue(nullptr);
-    }
-  }
-
-  static SkPoint processValue(const JsiValue &value) {
-    if (value.getType() == PropType::HostObject) {
-      // Try reading as point
-      auto ptr = std::dynamic_pointer_cast<JsiSkPoint>(value.getAsHostObject());
-      if (ptr != nullptr) {
-        return SkPoint::Make(ptr->getObject()->x(), ptr->getObject()->y());
-      } else {
-        // Try reading as rect
-        auto ptr =
-            std::dynamic_pointer_cast<JsiSkRect>(value.getAsHostObject());
-        if (ptr != nullptr) {
-          return SkPoint::Make(ptr->getObject()->x(), ptr->getObject()->y());
-        }
-      }
-    } else if (value.getType() == PropType::Object &&
-               value.hasValue(PropNameX) && value.hasValue(PropNameY)) {
-      auto x = value.getValue(PropNameX);
-      auto y = value.getValue(PropNameY);
-      return SkPoint::Make(x.getAsNumber(), y.getAsNumber());
-    }
-    throw std::runtime_error("Expected point value.");
-  }
-
-private:
-  NodeProp *_pointProp;
-};
-
-} // namespace RNSkia

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

@@ -1,81 +0,0 @@
-#pragma once
-
-#include "DerivedNodeProp.h"
-#include "JsiSkPoint.h"
-
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#include "include/core/SkPoint.h"
-
-#pragma clang diagnostic pop
-
-namespace RNSkia {
-
-class PointModeProp : public DerivedProp<SkCanvas::PointMode> {
-public:
-  explicit PointModeProp(PropId name,
-                         const std::function<void(BaseNodeProp *)> &onChange)
-      : DerivedProp<SkCanvas::PointMode>(onChange) {
-    _pointModeProp = defineProperty<NodeProp>(name);
-  }
-
-  void updateDerivedValue() override {
-    if (_pointModeProp->isSet()) {
-      setDerivedValue(
-          getPointModeFromStringValue(_pointModeProp->value().getAsString()));
-    } else {
-      setDerivedValue(nullptr);
-    }
-  }
-
-private:
-  static SkCanvas::PointMode
-  getPointModeFromStringValue(const std::string &value) {
-    if (value == "points") {
-      return SkCanvas::PointMode::kPoints_PointMode;
-    } else if (value == "lines") {
-      return SkCanvas::PointMode::kLines_PointMode;
-    } else if (value == "polygon") {
-      return SkCanvas::PointMode::kPolygon_PointMode;
-    }
-    throw std::runtime_error(
-        "Expected valid point mode for Points node, got \"" + value + "\".");
-  }
-
-  NodeProp *_pointModeProp;
-};
-
-class PointsProp : public DerivedProp<std::vector<SkPoint>> {
-public:
-  explicit PointsProp(PropId name,
-                      const std::function<void(BaseNodeProp *)> &onChange)
-      : DerivedProp<std::vector<SkPoint>>(onChange) {
-    _pointsProp = defineProperty<NodeProp>(name);
-  }
-
-  void updateDerivedValue() override {
-    if (_pointsProp->isSet()) {
-      auto pointsArray = _pointsProp->value().getAsArray();
-      std::vector<SkPoint> points;
-      points.reserve(pointsArray.size());
-      for (size_t i = 0; i < pointsArray.size(); ++i) {
-        auto p = pointsArray[i];
-        points.push_back(PointProp::processValue(p));
-      }
-      setDerivedValue(std::move(points));
-    } else {
-      setDerivedValue(nullptr);
-    }
-  }
-
-private:
-  NodeProp *_pointsProp;
-};
-
-} // namespace RNSkia