react-native-skia 0.0.1 → 3.0.0

package/cpp/api/recorder/Convertor.h

@@ -0,0 +1,1467 @@
+#pragma once
+
+#include <functional>
+#include <map>
+#include <optional>
+#include <variant>
+#include <vector>
+
+#include <include/core/SkBlurTypes.h>
+#include <include/core/SkPaint.h>
+#include <include/core/SkPathEffect.h>
+#include <include/core/SkPoint.h>
+#include <include/effects/Sk1DPathEffect.h>
+#include <include/effects/SkRuntimeEffect.h>
+#include <modules/skparagraph/include/Paragraph.h>
+#include <modules/skparagraph/include/ParagraphBuilder.h>
+#include <modules/skparagraph/include/ParagraphStyle.h>
+
+#include "../CustomBlendModes.h"
+#include "api/JsiSkFont.h"
+#include "api/JsiSkImage.h"
+#include "api/JsiSkImageFilter.h"
+#include "api/JsiSkMatrix.h"
+#include "api/JsiSkPaint.h"
+#include "api/JsiSkParagraph.h"
+#include "api/JsiSkPicture.h"
+#include "api/JsiSkRSXform.h"
+#include "api/JsiSkRuntimeEffect.h"
+#include "api/JsiSkSVG.h"
+#include "api/JsiSkSkottie.h"
+#include "api/JsiSkTextBlob.h"
+#include "api/third_party/CSSColorParser.h"
+
+#include "DataTypes.h"
+
+#include <jsi/jsi.h>
+
+namespace RNSkia {
+
+struct Radius {
+  float rX;
+  float rY;
+};
+
+// A value read from a shared value, waiting to be written into a command
+// property. Reading needs the runtime the shared value lives on; writing does
+// not, so the thread that replays the commands writes it right before.
+// Empty when there is nothing to write.
+using PendingWrite = std::function<void()>;
+using ConversionFunction = std::function<PendingWrite(
+    jsi::Runtime &runtime, const jsi::Object &object)>;
+using Variables = std::map<std::string, std::vector<ConversionFunction>>;
+
+using Patch = std::array<SkPoint, 12>;
+
+struct GlyphData {
+  std::vector<SkGlyphID> glyphIds;
+  std::vector<SkPoint> positions;
+};
+
+inline bool isSharedValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  return value.isObject() &&
+         value.asObject(runtime).hasProperty(runtime,
+                                             "_isReanimatedSharedValue") &&
+         value.asObject(runtime)
+             .getProperty(runtime, "_isReanimatedSharedValue")
+             .isBool() &&
+         value.asObject(runtime)
+                 .getProperty(runtime, "_isReanimatedSharedValue")
+                 .asBool() == true;
+}
+
+// Helper type traits
+template <typename T> struct is_optional : std::false_type {};
+
+template <typename T> struct is_optional<std::optional<T>> : std::true_type {};
+
+template <typename T> struct unwrap_optional {
+  using type = T;
+};
+
+template <typename T> struct unwrap_optional<std::optional<T>> {
+  using type = T;
+};
+
+// Property value getter declarations
+template <typename T>
+T getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value);
+
+template <typename T, typename Target>
+bool convertSelectorProperty(jsi::Runtime &runtime, const jsi::Value &prop,
+                             Target &target, Variables &variables) {
+  if (!prop.isObject()) {
+    return false;
+  }
+  auto wrapper = prop.asObject(runtime);
+  if (!wrapper.hasProperty(runtime, "__sv") ||
+      !wrapper.hasProperty(runtime, "__key")) {
+    return false;
+  }
+  auto svVal = wrapper.getProperty(runtime, "__sv");
+  auto keyVal = wrapper.getProperty(runtime, "__key");
+  if (!isSharedValue(runtime, svVal) || !keyVal.isString()) {
+    return false;
+  }
+  auto sharedValue = svVal.asObject(runtime);
+  auto key = keyVal.asString(runtime).utf8(runtime);
+  auto name =
+      sharedValue.getProperty(runtime, "name").asString(runtime).utf8(runtime);
+
+  auto conv = [target = &target, key](jsi::Runtime &runtime,
+                                      const jsi::Object &val) -> PendingWrite {
+    auto value = val.getProperty(runtime, "value");
+    if (!value.isObject()) {
+      return nullptr;
+    }
+    auto values = value.asObject(runtime);
+    if (!values.hasProperty(runtime, key.c_str())) {
+      return nullptr;
+    }
+
+    auto selected = values.getProperty(runtime, key.c_str());
+    if (selected.isUndefined() || selected.isNull() ||
+        (selected.isObject() &&
+         selected.asObject(runtime).isFunction(runtime))) {
+      return nullptr;
+    }
+    return
+        [target, converted = getPropertyValue<T>(runtime, selected)]() mutable {
+          *target = std::move(converted);
+        };
+  };
+
+  variables[name].push_back(conv);
+  if (auto write = conv(runtime, sharedValue)) {
+    write();
+  }
+  return true;
+}
+
+template <typename T, typename Target>
+void convertPropertyImpl(jsi::Runtime &runtime, const jsi::Object &object,
+                         const std::string &propertyName, Target &target,
+                         Variables &variables) {
+  if (!object.hasProperty(runtime, propertyName.c_str())) {
+    return;
+  }
+
+  auto prop = object.getProperty(runtime, propertyName.c_str());
+
+  if (convertSelectorProperty<T>(runtime, prop, target, variables)) {
+    return;
+  }
+
+  if (isSharedValue(runtime, prop)) {
+    auto sharedValue = prop.asObject(runtime);
+    auto name = sharedValue.getProperty(runtime, "name")
+                    .asString(runtime)
+                    .utf8(runtime);
+    auto conv = [target = &target](jsi::Runtime &runtime,
+                                   const jsi::Object &val) -> PendingWrite {
+      auto value = val.getProperty(runtime, "value");
+      return
+          [target, converted = getPropertyValue<T>(runtime, value)]() mutable {
+            *target = std::move(converted);
+          };
+    };
+    variables[name].push_back(conv);
+    if (auto write = conv(runtime, sharedValue)) {
+      write();
+    }
+    return;
+  }
+
+  target = getPropertyValue<T>(runtime, prop);
+}
+
+// Main convertProperty template
+template <typename T>
+void convertProperty(jsi::Runtime &runtime, const jsi::Object &object,
+                     const std::string &propertyName, T &target,
+                     Variables &variables) {
+  convertPropertyImpl<T>(runtime, object, propertyName, target, variables);
+}
+
+// Base property value getter implementations
+template <>
+inline float getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (value.isNumber()) {
+    return static_cast<float>(value.asNumber());
+  }
+  throw std::runtime_error("Invalid float prop value received");
+}
+
+template <>
+inline int getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (value.isNumber()) {
+    return static_cast<int>(value.asNumber());
+  }
+  throw std::runtime_error("Invalid int prop value received");
+}
+
+template <>
+inline std::string getPropertyValue(jsi::Runtime &runtime,
+                                    const jsi::Value &value) {
+  if (value.isString()) {
+    return value.asString(runtime).utf8(runtime);
+  }
+  throw std::runtime_error("Invalid string prop value received");
+}
+
+template <>
+inline SkPoint getPropertyValue(jsi::Runtime &runtime,
+                                const jsi::Value &value) {
+  if (value.isObject()) {
+    auto x = value.asObject(runtime).getProperty(runtime, "x").asNumber();
+    auto y = value.asObject(runtime).getProperty(runtime, "y").asNumber();
+    return SkPoint::Make(x, y);
+  }
+  throw std::runtime_error("Invalid prop value for SkPoint received");
+}
+
+template <>
+inline SkColor getPropertyValue(jsi::Runtime &runtime,
+                                const jsi::Value &value) {
+  if (value.isNumber()) {
+    return static_cast<SkColor>(value.asNumber());
+  } else if (value.isString()) {
+    auto text = value.asString(runtime).utf8(runtime);
+    auto color = CSSColorParser::parse(text);
+    if (color.a == -1.0f) {
+      return SK_ColorBLACK;
+    }
+    return SkColorSetARGB(color.a * 255, color.r, color.g, color.b);
+  } else if (value.isObject()) {
+    const auto &object = value.asObject(runtime);
+    if (object.isArray(runtime)) {
+      auto array = object.asArray(runtime);
+      auto r = array.getValueAtIndex(runtime, 0).asNumber();
+      auto g = array.getValueAtIndex(runtime, 1).asNumber();
+      auto b = array.getValueAtIndex(runtime, 2).asNumber();
+      auto a = array.getValueAtIndex(runtime, 3).asNumber();
+      return SkColorSetARGB(a * 255, r * 255, g * 255, b * 255);
+    }
+
+    // Check for properties "0", "1", "2", "3" (even if not an array)
+    auto prop0 = jsi::PropNameID::forAscii(runtime, "0");
+    auto prop1 = jsi::PropNameID::forAscii(runtime, "1");
+    auto prop2 = jsi::PropNameID::forAscii(runtime, "2");
+    auto prop3 = jsi::PropNameID::forAscii(runtime, "3");
+    if (object.hasProperty(runtime, prop0) &&
+        object.hasProperty(runtime, prop1) &&
+        object.hasProperty(runtime, prop2) &&
+        object.hasProperty(runtime, prop3)) {
+      auto r = object.getProperty(runtime, prop0).asNumber();
+      auto g = object.getProperty(runtime, prop1).asNumber();
+      auto b = object.getProperty(runtime, prop2).asNumber();
+      auto a = object.getProperty(runtime, prop3).asNumber();
+      return SkColorSetARGB(a * 255, r * 255, g * 255, b * 255);
+    }
+    jsi::ArrayBuffer buffer =
+        object
+            .getProperty(runtime, jsi::PropNameID::forAscii(runtime, "buffer"))
+            .asObject(runtime)
+            .getArrayBuffer(runtime);
+    auto bfrPtr = reinterpret_cast<float *>(buffer.data(runtime));
+    if (bfrPtr[0] > 1 || bfrPtr[1] > 1 || bfrPtr[2] > 1 || bfrPtr[3] > 1) {
+      return SK_ColorBLACK;
+    }
+    return SkColorSetARGB(bfrPtr[3] * 255, bfrPtr[0] * 255, bfrPtr[1] * 255,
+                          bfrPtr[2] * 255);
+  }
+  throw std::runtime_error("Invalid prop value for SkColor received");
+}
+
+template <>
+inline std::vector<SkColor> getPropertyValue(jsi::Runtime &runtime,
+                                             const jsi::Value &value) {
+  std::vector<SkColor> result;
+  if (value.isObject() && value.asObject(runtime).isArray(runtime)) {
+    auto array = value.asObject(runtime).asArray(runtime);
+    size_t size = array.size(runtime);
+    result.reserve(size);
+
+    for (size_t i = 0; i < size; i++) {
+      result.push_back(getPropertyValue<SkColor>(
+          runtime, array.getValueAtIndex(runtime, i)));
+    }
+  }
+  return result;
+}
+
+template <>
+inline SkTileMode getPropertyValue(jsi::Runtime &runtime,
+                                   const jsi::Value &val) {
+  if (val.isString()) {
+    auto value = val.asString(runtime).utf8(runtime);
+    if (value == "clamp") {
+      return SkTileMode::kClamp;
+    } else if (value == "repeat") {
+      return SkTileMode::kRepeat;
+    } else if (value == "mirror") {
+      return SkTileMode::kMirror;
+    } else if (value == "decal") {
+      return SkTileMode::kDecal;
+    }
+  }
+  throw std::runtime_error("Invalid value for SkTileMode received");
+}
+
+template <>
+inline SkColorChannel getPropertyValue(jsi::Runtime &runtime,
+                                       const jsi::Value &val) {
+  if (val.isString()) {
+    auto value = val.asString(runtime).utf8(runtime);
+    if (value == "r") {
+      return SkColorChannel::kR;
+    } else if (value == "b") {
+      return SkColorChannel::kB;
+    } else if (value == "g") {
+      return SkColorChannel::kG;
+    } else if (value == "a") {
+      return SkColorChannel::kA;
+    }
+  }
+  throw std::runtime_error("Invalid value for SkTileMode received");
+}
+
+template <>
+inline SkVertices::VertexMode getPropertyValue(jsi::Runtime &runtime,
+                                               const jsi::Value &val) {
+  if (val.isString()) {
+    auto value = val.asString(runtime).utf8(runtime);
+    if (value == "triangles") {
+      return SkVertices::VertexMode::kTriangles_VertexMode;
+    } else if (value == "triangleStrip") {
+      return SkVertices::VertexMode::kTriangleStrip_VertexMode;
+    } else if (value == "triangleFan") {
+      return SkVertices::VertexMode::kTriangleFan_VertexMode;
+    }
+  }
+  throw std::runtime_error("Invalid value for VertexMode received");
+}
+
+template <>
+inline SkM44 getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (value.isObject()) {
+    auto object = value.asObject(runtime);
+    // Get array of property names
+    auto array = object.asArray(runtime);
+    auto size = array.size(runtime);
+    SkM44 m4;
+    for (int i = 0; i < size; i++) {
+      auto value = array.getValueAtIndex(runtime, i).asObject(runtime);
+      auto propNames = value.getPropertyNames(runtime);
+      if (propNames.size(runtime) == 0) {
+        throw std::runtime_error(
+            "Empty value in transform. Expected translateX, translateY, "
+            "scale, "
+            "scaleX, scaleY, skewX, skewY, rotate or rotateZ.");
+      }
+      auto key =
+          propNames.getValueAtIndex(runtime, 0).asString(runtime).utf8(runtime);
+      if (key == "translateX") {
+        auto x = value.getProperty(runtime, key.c_str()).asNumber();
+        m4.preTranslate(x, 0, 0);
+      } else if (key == "translateY") {
+        auto y = value.getProperty(runtime, key.c_str()).asNumber();
+        m4.preTranslate(0, y, 0);
+      } else if (key == "translateZ") {
+        auto z = value.getProperty(runtime, key.c_str()).asNumber();
+        m4.preTranslate(0, 0, z);
+      } else if (key == "translate") {
+        auto arr = value.getProperty(runtime, key.c_str())
+                       .asObject(runtime)
+                       .asArray(runtime);
+        double x = 0, y = 0, z = 0;
+        for (int i = 0; i < arr.size(runtime); i++) {
+          if (i == 0) {
+            x = arr.getValueAtIndex(runtime, i).asNumber();
+          } else if (i == 1) {
+            y = arr.getValueAtIndex(runtime, i).asNumber();
+          } else if (i == 2) {
+            z = arr.getValueAtIndex(runtime, i).asNumber();
+          }
+        }
+        m4.preTranslate(x, y, z);
+      } else if (key == "scale") {
+        auto s = value.getProperty(runtime, key.c_str()).asNumber();
+        m4.preScale(s, s);
+      } else if (key == "scaleX") {
+        auto s = value.getProperty(runtime, key.c_str()).asNumber();
+        m4.preScale(s, 1);
+      } else if (key == "scaleY") {
+        auto s = value.getProperty(runtime, key.c_str()).asNumber();
+        m4.preScale(1, s);
+      } else if (key == "skewX") {
+        auto angle = value.getProperty(runtime, key.c_str()).asNumber();
+        // The SkM44 constructor takes its arguments in row-major reading
+        // order, so the shear factor of a horizontal skew belongs in row 0,
+        // where it scales y into x.
+        SkM44 skewX(1, std::tan(angle), 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+                    1);
+        m4.preConcat(skewX);
+
+      } else if (key == "skewY") {
+        auto angle = value.getProperty(runtime, key.c_str()).asNumber();
+        SkM44 skewY(1, 0, 0, 0, std::tan(angle), 1, 0, 0, 0, 0, 1, 0, 0, 0, 0,
+                    1);
+        m4.preConcat(skewY);
+      } else if (key == "rotate" || key == "rotateZ") {
+        auto angle = value.getProperty(runtime, key.c_str()).asNumber();
+        SkM44 rotate;
+        rotate.setRotateUnit({0, 0, 1}, angle);
+        m4.preConcat(rotate);
+      } else if (key == "rotateY") {
+        auto angle = value.getProperty(runtime, key.c_str()).asNumber();
+        SkM44 rotate;
+        rotate.setRotateUnit({0, 1, 0}, angle);
+        m4.preConcat(rotate);
+      } else if (key == "rotateX") {
+        auto angle = value.getProperty(runtime, key.c_str()).asNumber();
+        SkM44 rotate;
+        rotate.setRotateUnit({1, 0, 0}, angle);
+        m4.preConcat(rotate);
+      } else if (key == "perspective") {
+        auto p = value.getProperty(runtime, key.c_str()).asNumber();
+        SkM44 perspective(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, -1 / p, 1);
+        m4.preConcat(perspective);
+      } else if (key == "matrix") {
+        auto arr = value.getProperty(runtime, key.c_str())
+                       .asObject(runtime)
+                       .asArray(runtime);
+        SkM44 m44;
+        for (size_t i = 0; i < arr.size(runtime); ++i) {
+          auto obj = arr.getValueAtIndex(runtime, i);
+          m44.setRC(i / 4, i % 4, obj.asNumber());
+        }
+        m4.preConcat(m44);
+      } else {
+        throw std::runtime_error(
+            "Unknown key in transform. Expected translateX, translateY, "
+            "scale, "
+            "scaleX, scaleY, skewX, skewY, rotate or rotateZ - got " +
+            std::string(key) + ".");
+      }
+    }
+    return m4;
+  }
+  throw std::runtime_error("Invalid prop value for SkM44 received");
+}
+
+template <>
+inline SkSamplingOptions getPropertyValue(jsi::Runtime &runtime,
+                                          const jsi::Value &value) {
+  if (value.isObject()) {
+    SkSamplingOptions samplingOptions(SkFilterMode::kLinear);
+    auto object = value.asObject(runtime);
+    if (object.hasProperty(runtime, "B") && object.hasProperty(runtime, "C")) {
+      auto B = static_cast<float>(object.getProperty(runtime, "B").asNumber());
+      auto C = static_cast<float>(object.getProperty(runtime, "C").asNumber());
+      samplingOptions = SkSamplingOptions({B, C});
+    } else if (object.hasProperty(runtime, "filter")) {
+      auto filter = static_cast<SkFilterMode>(
+          object.getProperty(runtime, "filter").asNumber());
+      if (object.hasProperty(runtime, "mipmap")) {
+        auto mipmap = static_cast<SkMipmapMode>(
+            object.getProperty(runtime, "mipmap").asNumber());
+        samplingOptions = SkSamplingOptions(filter, mipmap);
+      } else {
+        samplingOptions = SkSamplingOptions(filter);
+      }
+    }
+    return samplingOptions;
+  }
+
+  throw std::runtime_error("Invalid prop value for SkSamplingOptions received");
+}
+
+template <>
+inline SkFont getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (value.isObject()) {
+    auto font = getJsiObject<JsiSkFont>(runtime, value)->getObject();
+    return SkFont(*font);
+  }
+  throw std::runtime_error("Invalid prop value for SkFont received");
+}
+
+template <>
+inline GlyphData getPropertyValue(jsi::Runtime &runtime,
+                                  const jsi::Value &value) {
+  GlyphData result;
+  if (value.isObject() && value.asObject(runtime).isArray(runtime)) {
+    auto array = value.asObject(runtime).asArray(runtime);
+    size_t size = array.size(runtime);
+    result.glyphIds.reserve(size);
+    result.positions.reserve(size);
+
+    for (size_t i = 0; i < size; i++) {
+      auto glyph = array.getValueAtIndex(runtime, i).asObject(runtime);
+      // Get the glyph id
+      result.glyphIds.push_back(
+          static_cast<SkGlyphID>(glyph.getProperty(runtime, "id").asNumber()));
+      // Get the position
+      result.positions.push_back(
+          processPoint(runtime, glyph.getProperty(runtime, "pos")));
+    }
+    return result;
+  }
+  throw std::runtime_error("Invalid prop value for GlyphData received");
+}
+
+template <>
+inline SkRSXform getPropertyValue(jsi::Runtime &runtime,
+                                  const jsi::Value &value) {
+  if (value.isObject()) {
+    auto form = getJsiObject<JsiSkRSXform>(runtime, value)->getObject();
+    return SkRSXform::Make(form->fSCos, form->fSSin, form->fTx, form->fTy);
+  }
+  throw std::runtime_error("Invalid prop value for SkRSXform received");
+}
+
+template <>
+inline sk_sp<SkSVGDOM> getPropertyValue(jsi::Runtime &runtime,
+                                        const jsi::Value &value) {
+  auto ptr = tryGetJsiObject<JsiSkSVG>(runtime, value);
+  if (ptr != nullptr) {
+    return ptr->getObject();
+  }
+  if (value.isNull()) {
+    return nullptr;
+  }
+  throw std::runtime_error(
+      "Expected SkSvgDom object or null for the svg property.");
+}
+
+template <>
+inline sk_sp<skottie::Animation> getPropertyValue(jsi::Runtime &runtime,
+                                                  const jsi::Value &value) {
+  auto ptr = tryGetJsiObject<JsiSkSkottie>(runtime, value);
+  if (ptr != nullptr) {
+    return ptr->getObject()->_animation;
+  }
+  if (value.isNull()) {
+    return nullptr;
+  }
+  throw std::runtime_error(
+      "Expected JsiSkSkottie object or null for the svg property.");
+}
+
+template <>
+inline sk_sp<SkImageFilter> getPropertyValue(jsi::Runtime &runtime,
+                                             const jsi::Value &value) {
+  auto ptr = tryGetJsiObject<JsiSkImageFilter>(runtime, value);
+  if (ptr != nullptr) {
+    return ptr->getObject();
+  }
+  if (value.isNull()) {
+    return nullptr;
+  }
+  throw std::runtime_error(
+      "Expected JsiSkImageFilter object or null for the imageFilter property.");
+}
+
+template <>
+inline sk_sp<SkPicture> getPropertyValue(jsi::Runtime &runtime,
+                                         const jsi::Value &value) {
+  if (value.isObject()) {
+    auto picture = getJsiObject<JsiSkPicture>(runtime, value)->getObject();
+    return picture;
+  }
+  throw std::runtime_error("Invalid prop value for SkTextBlob received");
+}
+
+template <>
+inline SkPaint getPropertyValue(jsi::Runtime &runtime,
+                                const jsi::Value &value) {
+  if (value.isObject()) {
+    auto paint = getJsiObject<JsiSkPaint>(runtime, value)->getObject();
+    return SkPaint(*paint);
+  }
+  throw std::runtime_error("Invalid prop value for SkPaint received");
+}
+
+template <>
+inline std::shared_ptr<JsiSkParagraph>
+getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  // Return a shared_ptr instead of raw pointer
+  return tryGetJsiObject<JsiSkParagraph>(runtime, value);
+}
+
+template <>
+inline sk_sp<SkTextBlob> getPropertyValue(jsi::Runtime &runtime,
+                                          const jsi::Value &value) {
+  if (value.isObject()) {
+    auto blob = getJsiObject<JsiSkTextBlob>(runtime, value)->getObject();
+    return blob;
+  }
+  throw std::runtime_error("Invalid prop value for SkTextBlob received");
+}
+
+template <>
+inline sk_sp<SkRuntimeEffect> getPropertyValue(jsi::Runtime &runtime,
+                                               const jsi::Value &value) {
+  if (value.isObject()) {
+    auto effect = getJsiObject<JsiSkRuntimeEffect>(runtime, value)->getObject();
+    return effect;
+  }
+  throw std::runtime_error("Invalid prop value for SkRuntimeEffect received");
+}
+
+template <>
+inline sk_sp<SkImage> getPropertyValue(jsi::Runtime &runtime,
+                                       const jsi::Value &value) {
+
+  if (value.isObject()) {
+    auto effect = getJsiObject<JsiSkImage>(runtime, value)->getObject();
+    return effect;
+  } else if (value.isNull()) {
+    return nullptr;
+  }
+  throw std::runtime_error("Invalid prop value for SkImage received");
+}
+
+template <>
+inline SkMatrix getPropertyValue(jsi::Runtime &runtime,
+                                 const jsi::Value &value) {
+  if (value.isObject()) {
+    auto ptr = tryGetJsiObject<JsiSkMatrix>(runtime, value);
+    if (ptr != nullptr) {
+      auto matrix = ptr->getObject().get();
+      return SkMatrix(*matrix);
+    } else {
+      return JsiSkMatrix::getMatrix(runtime, value);
+    }
+  }
+  throw std::runtime_error("Invalid prop value for SkMatrix received");
+}
+
+template <>
+inline Radius getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (value.isObject()) {
+    auto object = value.asObject(runtime);
+    auto rX = static_cast<float>(object.getProperty(runtime, "x").asNumber());
+    auto rY = static_cast<float>(object.getProperty(runtime, "y").asNumber());
+    return {rX, rY};
+  } else if (value.isNumber()) {
+    auto r = static_cast<float>(value.asNumber());
+    return {r, r};
+  }
+  throw std::runtime_error("Invalid prop value for Radius received");
+}
+
+template <>
+inline SkCanvas::PointMode getPropertyValue(jsi::Runtime &runtime,
+                                            const jsi::Value &val) {
+  if (val.isString()) {
+    auto value = val.asString(runtime).utf8(runtime);
+    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(
+      "Invalid prop value for SkCanvas::PointMode received");
+}
+
+template <>
+inline SkPaint::Style getPropertyValue(jsi::Runtime &runtime,
+                                       const jsi::Value &val) {
+  if (val.isString()) {
+    auto value = val.asString(runtime).utf8(runtime);
+    if (value == "fill") {
+      return SkPaint::kFill_Style;
+    } else if (value == "stroke") {
+      return SkPaint::kStroke_Style;
+    }
+  }
+  throw std::runtime_error("Invalid prop value for SkPaint::Style received");
+}
+
+template <>
+inline SkPaint::Join getPropertyValue(jsi::Runtime &runtime,
+                                      const jsi::Value &val) {
+  if (val.isString()) {
+    auto value = val.asString(runtime).utf8(runtime);
+    if (value == "miter") {
+      return SkPaint::kMiter_Join;
+    } else if (value == "round") {
+      return SkPaint::kRound_Join;
+    } else if (value == "bevel") {
+      return SkPaint::kBevel_Join;
+    }
+  }
+  throw std::runtime_error("Invalid prop value for SkPaint::Join received");
+}
+
+template <>
+inline SkPaint::Cap getPropertyValue(jsi::Runtime &runtime,
+                                     const jsi::Value &val) {
+  if (val.isString()) {
+    auto value = val.asString(runtime).utf8(runtime);
+    if (value == "butt") {
+      return SkPaint::kButt_Cap;
+    } else if (value == "round") {
+      return SkPaint::kRound_Cap;
+    } else if (value == "square") {
+      return SkPaint::kSquare_Cap;
+    }
+  }
+  throw std::runtime_error("Invalid prop value for SkPaint::Cap received");
+}
+
+template <>
+inline SkPath1DPathEffect::Style getPropertyValue(jsi::Runtime &runtime,
+                                                  const jsi::Value &val) {
+  if (val.isString()) {
+    auto value = val.asString(runtime).utf8(runtime);
+    if (value == "translate") {
+      return SkPath1DPathEffect::Style::kTranslate_Style;
+    } else if (value == "rotate") {
+      return SkPath1DPathEffect::Style::kRotate_Style;
+    } else if (value == "morph") {
+      return SkPath1DPathEffect::Style::kMorph_Style;
+    }
+  }
+  throw std::runtime_error("Invalid prop value for Path1DEffectStyle received");
+}
+
+// Wrapper type for blend mode to avoid conflict with int template
+// specialization
+struct BlendModeValue {
+  int value;
+  explicit BlendModeValue(int v = 0) : value(v) {}
+  operator int() const { return value; }
+};
+
+template <>
+inline BlendModeValue getPropertyValue(jsi::Runtime &runtime,
+                                       const jsi::Value &val) {
+  if (val.isString()) {
+    auto value = val.asString(runtime).utf8(runtime);
+    if (value == "clear") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kClear));
+    } else if (value == "src") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kSrc));
+    } else if (value == "dst") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kDst));
+    } else if (value == "srcOver") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kSrcOver));
+    } else if (value == "dstOver") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kDstOver));
+    } else if (value == "srcIn") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kSrcIn));
+    } else if (value == "dstIn") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kDstIn));
+    } else if (value == "srcOut") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kSrcOut));
+    } else if (value == "dstOut") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kDstOut));
+    } else if (value == "srcATop") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kSrcATop));
+    } else if (value == "dstATop") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kDstATop));
+    } else if (value == "xor") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kXor));
+    } else if (value == "plus") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kPlus));
+    } else if (value == "modulate") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kModulate));
+    } else if (value == "screen") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kScreen));
+    } else if (value == "overlay") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kOverlay));
+    } else if (value == "darken") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kDarken));
+    } else if (value == "lighten") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kLighten));
+    } else if (value == "colorDodge") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kColorDodge));
+    } else if (value == "colorBurn") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kColorBurn));
+    } else if (value == "hardLight") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kHardLight));
+    } else if (value == "softLight") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kSoftLight));
+    } else if (value == "difference") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kDifference));
+    } else if (value == "exclusion") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kExclusion));
+    } else if (value == "multiply") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kMultiply));
+    } else if (value == "hue") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kHue));
+    } else if (value == "saturation") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kSaturation));
+    } else if (value == "color") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kColor));
+    } else if (value == "luminosity") {
+      return BlendModeValue(static_cast<int>(SkBlendMode::kLuminosity));
+    } else if (value == "plusDarker") {
+      return BlendModeValue(kBlendModePlusDarker);
+    } else if (value == "plusLighter") {
+      return BlendModeValue(kBlendModePlusLighter);
+    }
+  }
+  throw std::runtime_error("Invalid prop value for BlendMode received");
+}
+
+// Keep SkBlendMode specialization for other usages (Shaders, ImageFilters,
+// ColorFilters, Drawings)
+template <>
+inline SkBlendMode getPropertyValue(jsi::Runtime &runtime,
+                                    const jsi::Value &val) {
+  if (val.isString()) {
+    auto value = val.asString(runtime).utf8(runtime);
+    if (value == "clear") {
+      return SkBlendMode::kClear;
+    } else if (value == "src") {
+      return SkBlendMode::kSrc;
+    } else if (value == "dst") {
+      return SkBlendMode::kDst;
+    } else if (value == "srcOver") {
+      return SkBlendMode::kSrcOver;
+    } else if (value == "dstOver") {
+      return SkBlendMode::kDstOver;
+    } else if (value == "srcIn") {
+      return SkBlendMode::kSrcIn;
+    } else if (value == "dstIn") {
+      return SkBlendMode::kDstIn;
+    } else if (value == "srcOut") {
+      return SkBlendMode::kSrcOut;
+    } else if (value == "dstOut") {
+      return SkBlendMode::kDstOut;
+    } else if (value == "srcATop") {
+      return SkBlendMode::kSrcATop;
+    } else if (value == "dstATop") {
+      return SkBlendMode::kDstATop;
+    } else if (value == "xor") {
+      return SkBlendMode::kXor;
+    } else if (value == "plus") {
+      return SkBlendMode::kPlus;
+    } else if (value == "modulate") {
+      return SkBlendMode::kModulate;
+    } else if (value == "screen") {
+      return SkBlendMode::kScreen;
+    } else if (value == "overlay") {
+      return SkBlendMode::kOverlay;
+    } else if (value == "darken") {
+      return SkBlendMode::kDarken;
+    } else if (value == "lighten") {
+      return SkBlendMode::kLighten;
+    } else if (value == "colorDodge") {
+      return SkBlendMode::kColorDodge;
+    } else if (value == "colorBurn") {
+      return SkBlendMode::kColorBurn;
+    } else if (value == "hardLight") {
+      return SkBlendMode::kHardLight;
+    } else if (value == "softLight") {
+      return SkBlendMode::kSoftLight;
+    } else if (value == "difference") {
+      return SkBlendMode::kDifference;
+    } else if (value == "exclusion") {
+      return SkBlendMode::kExclusion;
+    } else if (value == "multiply") {
+      return SkBlendMode::kMultiply;
+    } else if (value == "hue") {
+      return SkBlendMode::kHue;
+    } else if (value == "saturation") {
+      return SkBlendMode::kSaturation;
+    } else if (value == "color") {
+      return SkBlendMode::kColor;
+    } else if (value == "luminosity") {
+      return SkBlendMode::kLuminosity;
+    }
+  }
+  throw std::runtime_error("Invalid prop value for SkBlendMode received");
+}
+
+using ClipDef = std::variant<SkPath, SkRRect, SkRect, std::string>;
+using Layer = std::variant<SkPaint, bool>;
+
+template <>
+inline Uniforms getPropertyValue(jsi::Runtime &runtime,
+                                 const jsi::Value &value) {
+  if (value.isObject()) {
+    Uniforms result;
+    auto obj = value.asObject(runtime);
+    auto names = obj.getPropertyNames(runtime);
+
+    for (size_t i = 0; i < names.length(runtime); i++) {
+      std::string propName =
+          names.getValueAtIndex(runtime, i).toString(runtime).utf8(runtime);
+      jsi::Value propValue = obj.getProperty(runtime, propName.c_str());
+
+      if (propValue.isNumber()) {
+        result[propName] =
+            std::vector<float>{static_cast<float>(propValue.asNumber())};
+      } else if (propValue.isObject() &&
+                 propValue.asObject(runtime).isArray(runtime)) {
+        result[propName] =
+            processArray(runtime, propValue.asObject(runtime).asArray(runtime));
+      } else if (propValue.isObject() && isJSPoint(runtime, propValue)) {
+        result[propName] = {static_cast<float>(propValue.asObject(runtime)
+                                                   .getProperty(runtime, "x")
+                                                   .asNumber()),
+                            static_cast<float>(propValue.asObject(runtime)
+                                                   .getProperty(runtime, "y")
+                                                   .asNumber())};
+      } else if (propValue.isObject() && isIndexable(runtime, propValue)) {
+        auto indexableObj = propValue.asObject(runtime);
+        std::vector<float> values;
+        values.reserve(4);
+        for (int i = 0; i < 4; i++) {
+          if (indexableObj.hasProperty(runtime, std::to_string(i).c_str())) {
+            values.push_back(static_cast<float>(
+                indexableObj.getProperty(runtime, std::to_string(i).c_str())
+                    .asNumber()));
+          }
+        }
+        result[propName] = values;
+      }
+    }
+    return result;
+  }
+
+  throw std::runtime_error("Invalid prop value for Uniforms received");
+}
+
+template <>
+inline SkBlurStyle getPropertyValue(jsi::Runtime &runtime,
+                                    const jsi::Value &value) {
+  if (value.isString()) {
+    auto valueStr = value.asString(runtime).utf8(runtime);
+    if (valueStr == "normal") {
+      return SkBlurStyle::kNormal_SkBlurStyle;
+    } else if (valueStr == "solid") {
+      return SkBlurStyle::kSolid_SkBlurStyle;
+    } else if (valueStr == "outer") {
+      return SkBlurStyle::kOuter_SkBlurStyle;
+    } else if (valueStr == "inner") {
+      return SkBlurStyle::kInner_SkBlurStyle;
+    }
+  }
+  throw std::runtime_error("Invalid prop value for SkBlurStyle received");
+}
+
+template <>
+inline SkPathFillType getPropertyValue(jsi::Runtime &runtime,
+                                       const jsi::Value &value) {
+  if (value.isString()) {
+    auto valueStr = value.asString(runtime).utf8(runtime);
+    if (valueStr == "winding") {
+      return SkPathFillType::kWinding;
+    } else if (valueStr == "evenOdd") {
+      return SkPathFillType::kEvenOdd;
+    } else if (valueStr == "inverseWinding") {
+      return SkPathFillType::kInverseWinding;
+    } else if (valueStr == "inverseEvenOdd") {
+      return SkPathFillType::kInverseEvenOdd;
+    }
+  }
+  throw std::runtime_error("Invalid prop value for SkPathFillType received");
+}
+
+struct StrokeOpts {
+  std::optional<float> width;
+  std::optional<float> miter_limit;
+  std::optional<float> precision;
+  std::optional<SkPaint::Join> join;
+  std::optional<SkPaint::Cap> cap;
+};
+
+template <>
+inline StrokeOpts getPropertyValue(jsi::Runtime &runtime,
+                                   const jsi::Value &value) {
+  if (value.isObject()) {
+    StrokeOpts opts;
+    auto object = value.asObject(runtime);
+    if (object.hasProperty(runtime, "width")) {
+      opts.width = object.getProperty(runtime, "width").asNumber();
+    }
+    if (object.hasProperty(runtime, "miterLimit")) {
+      opts.miter_limit = object.getProperty(runtime, "miterLimit").asNumber();
+    }
+    if (object.hasProperty(runtime, "precision")) {
+      opts.precision = object.getProperty(runtime, "precision").asNumber();
+    }
+    if (object.hasProperty(runtime, "join")) {
+      opts.join = getPropertyValue<SkPaint::Join>(
+          runtime, object.getProperty(runtime, "join"));
+    }
+    if (object.hasProperty(runtime, "cap")) {
+      opts.cap = getPropertyValue<SkPaint::Cap>(
+          runtime, object.getProperty(runtime, "cap"));
+    }
+    return opts;
+  }
+  throw std::runtime_error("Invalid prop value for StrokeOpts received");
+}
+
+template <>
+inline SkRRect getPropertyValue(jsi::Runtime &runtime,
+                                const jsi::Value &value) {
+  if (value.isObject()) {
+    auto rect = processRRect(runtime, value);
+    if (!rect) {
+      throw std::runtime_error("Invalid prop value for SkRRect received");
+    }
+    return SkRRect(*rect);
+  }
+  throw std::runtime_error("Invalid prop value for SkRRect received");
+}
+
+template <>
+inline SkRect getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (value.isObject()) {
+    auto rect = processRect(runtime, value);
+    if (!rect) {
+      throw std::runtime_error("Invalid prop value for SkRect received");
+    }
+    return SkRect(*rect);
+  }
+  throw std::runtime_error("Invalid prop value for SkRect received");
+}
+
+template <>
+inline std::variant<SkRect, SkRRect> getPropertyValue(jsi::Runtime &runtime,
+                                                      const jsi::Value &value) {
+  if (value.isObject()) {
+    auto rect = processRect(runtime, value);
+    if (rect) {
+      return SkRect(*rect);
+    }
+    auto rrect = processRRect(runtime, value);
+    if (rrect) {
+      return SkRRect(*rrect);
+    }
+  }
+  throw std::runtime_error("Invalid prop value for SkRect received");
+}
+
+template <>
+inline SkPath getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  auto path = processPath(runtime, value);
+  if (!path) {
+    throw std::runtime_error("Invalid prop value for SkPath received");
+  }
+  return SkPath(*path);
+}
+
+template <>
+inline ClipDef getPropertyValue(jsi::Runtime &runtime,
+                                const jsi::Value &value) {
+  auto path = processPath(runtime, value);
+  if (path) {
+    ClipDef def = SkPath(*path);
+    return def;
+  }
+  auto rect = processRect(runtime, value);
+  if (rect) {
+    ClipDef def = SkRect(*rect);
+    return def;
+  }
+  auto rrect = processRRect(runtime, value);
+  if (rrect) {
+    ClipDef def = SkRRect(*rrect);
+    return def;
+  }
+  throw std::runtime_error("Invalid prop value for ClipDef received");
+}
+
+template <>
+inline Layer getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (value.isBool()) {
+    Layer layer = value.asBool();
+    return layer;
+  }
+  auto ptr = tryGetJsiObject<JsiSkPaint>(runtime, value);
+  if (ptr != nullptr) {
+    auto paint = ptr->getObject();
+    Layer layer = SkPaint(*paint);
+    return layer;
+  }
+  throw std::runtime_error("Invalid prop value for Layer received");
+}
+
+template <>
+inline Patch getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (value.isObject() && value.asObject(runtime).isArray(runtime)) {
+    auto array = value.asObject(runtime).asArray(runtime);
+    if (array.size(runtime) != 4) {
+      throw std::runtime_error("Patch must contain exactly 4 bezier handles");
+    }
+
+    // Patch requires points in the following order:
+    // M tl
+    // C c1 c2 br
+    // C c1 c2 bl
+    // C c1 c2 tl (the redundant point in the last command is removed)
+
+    Patch result;
+
+    result[0] = processPoint(runtime, array.getValueAtIndex(runtime, 0)
+                                          .asObject(runtime)
+                                          .getProperty(runtime, "pos"));
+    result[1] = processPoint(runtime, array.getValueAtIndex(runtime, 0)
+                                          .asObject(runtime)
+                                          .getProperty(runtime, "c2"));
+    result[2] = processPoint(runtime, array.getValueAtIndex(runtime, 1)
+                                          .asObject(runtime)
+                                          .getProperty(runtime, "c1"));
+    result[3] = processPoint(runtime, array.getValueAtIndex(runtime, 1)
+                                          .asObject(runtime)
+                                          .getProperty(runtime, "pos"));
+    result[4] = processPoint(runtime, array.getValueAtIndex(runtime, 1)
+                                          .asObject(runtime)
+                                          .getProperty(runtime, "c2"));
+    result[5] = processPoint(runtime, array.getValueAtIndex(runtime, 2)
+                                          .asObject(runtime)
+                                          .getProperty(runtime, "c1"));
+    result[6] = processPoint(runtime, array.getValueAtIndex(runtime, 2)
+                                          .asObject(runtime)
+                                          .getProperty(runtime, "pos"));
+    result[7] = processPoint(runtime, array.getValueAtIndex(runtime, 2)
+                                          .asObject(runtime)
+                                          .getProperty(runtime, "c2"));
+    result[8] = processPoint(runtime, array.getValueAtIndex(runtime, 3)
+                                          .asObject(runtime)
+                                          .getProperty(runtime, "c1"));
+    result[9] = processPoint(runtime, array.getValueAtIndex(runtime, 3)
+                                          .asObject(runtime)
+                                          .getProperty(runtime, "pos"));
+    result[10] = processPoint(runtime, array.getValueAtIndex(runtime, 3)
+                                           .asObject(runtime)
+                                           .getProperty(runtime, "c2"));
+    result[11] = processPoint(runtime, array.getValueAtIndex(runtime, 0)
+                                           .asObject(runtime)
+                                           .getProperty(runtime, "c1"));
+
+    return result;
+  }
+  throw std::runtime_error("Invalid prop value for Patch received");
+}
+
+template <>
+inline std::vector<SkRSXform> getPropertyValue(jsi::Runtime &runtime,
+                                               const jsi::Value &value) {
+  std::vector<SkRSXform> result;
+  if (value.isObject() && value.asObject(runtime).isArray(runtime)) {
+    auto array = value.asObject(runtime).asArray(runtime);
+    size_t size = array.size(runtime);
+    result.reserve(size);
+
+    for (size_t i = 0; i < size; i++) {
+      result.push_back(getPropertyValue<SkRSXform>(
+          runtime, array.getValueAtIndex(runtime, i)));
+    }
+  }
+  return result;
+}
+
+template <>
+inline std::vector<SkPoint> getPropertyValue(jsi::Runtime &runtime,
+                                             const jsi::Value &value) {
+  std::vector<SkPoint> result;
+  if (value.isObject() && value.asObject(runtime).isArray(runtime)) {
+    auto array = value.asObject(runtime).asArray(runtime);
+    size_t size = array.size(runtime);
+    result.reserve(size);
+
+    for (size_t i = 0; i < size; i++) {
+      auto point = processPoint(runtime, array.getValueAtIndex(runtime, i));
+      result.push_back(point);
+    }
+  }
+  return result;
+}
+
+template <>
+inline std::vector<SkRect> getPropertyValue(jsi::Runtime &runtime,
+                                            const jsi::Value &value) {
+  std::vector<SkRect> result;
+  if (value.isObject() && value.asObject(runtime).isArray(runtime)) {
+    auto array = value.asObject(runtime).asArray(runtime);
+    size_t size = array.size(runtime);
+    result.reserve(size);
+
+    for (size_t i = 0; i < size; i++) {
+      auto rect = processRect(runtime, array.getValueAtIndex(runtime, i));
+      if (rect) {
+        result.push_back(*rect);
+      } else {
+        throw std::runtime_error("Invalid rect in array at index " +
+                                 std::to_string(i));
+      }
+    }
+  }
+  return result;
+}
+
+template <>
+inline std::vector<float> getPropertyValue(jsi::Runtime &runtime,
+                                           const jsi::Value &value) {
+  std::vector<float> result;
+
+  if (value.isNumber()) {
+    // If single number, create a vector with one element
+    result.push_back(static_cast<float>(value.asNumber()));
+  } else if (value.isObject()) {
+    auto obj = value.asObject(runtime);
+    if (obj.isArray(runtime)) {
+      auto array = obj.asArray(runtime);
+      size_t size = array.size(runtime);
+      result.reserve(size);
+
+      for (size_t i = 0; i < size; i++) {
+        jsi::Value element = array.getValueAtIndex(runtime, i);
+        if (element.isNumber()) {
+          result.push_back(static_cast<float>(element.asNumber()));
+        } else {
+          throw std::runtime_error("Array elements must be numbers");
+        }
+      }
+    } else {
+      throw std::runtime_error("Expected array or number for vector<float>");
+    }
+  } else {
+    throw std::runtime_error("Invalid value type for vector<float>");
+  }
+
+  return result;
+}
+
+template <>
+inline std::vector<uint16_t> getPropertyValue(jsi::Runtime &runtime,
+                                              const jsi::Value &value) {
+  std::vector<uint16_t> result;
+
+  if (value.isNumber()) {
+    // If single number, create a vector with one element
+    result.push_back(static_cast<float>(value.asNumber()));
+  } else if (value.isObject()) {
+    auto obj = value.asObject(runtime);
+    if (obj.isArray(runtime)) {
+      auto array = obj.asArray(runtime);
+      size_t size = array.size(runtime);
+      result.reserve(size);
+
+      for (size_t i = 0; i < size; i++) {
+        jsi::Value element = array.getValueAtIndex(runtime, i);
+        if (element.isNumber()) {
+          result.push_back(static_cast<uint16_t>(element.asNumber()));
+        } else {
+          throw std::runtime_error("Array elements must be numbers");
+        }
+      }
+    } else {
+      throw std::runtime_error("Expected array or number for vector<uint16_t>");
+    }
+  } else {
+    throw std::runtime_error("Invalid value type for vector<uint16_t>");
+  }
+
+  return result;
+}
+
+template <>
+inline bool getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  if (value.isBool()) {
+    return value.asBool();
+  }
+  throw std::runtime_error("Invalid prop value for bool received");
+}
+
+//
+template <typename T>
+std::optional<T> makeOptionalPropertyValue(jsi::Runtime &runtime,
+                                           const jsi::Value &value) {
+  if (value.isNull() || value.isUndefined()) {
+    return std::nullopt;
+  }
+  try {
+    return getPropertyValue<T>(runtime, value);
+  } catch (const std::runtime_error &) {
+    return std::nullopt;
+  }
+}
+
+template <>
+inline std::optional<float> getPropertyValue(jsi::Runtime &runtime,
+                                             const jsi::Value &value) {
+  return makeOptionalPropertyValue<float>(runtime, value);
+}
+
+template <>
+inline std::optional<SkPoint> getPropertyValue(jsi::Runtime &runtime,
+                                               const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkPoint>(runtime, value);
+}
+
+template <>
+inline std::optional<SkColor> getPropertyValue(jsi::Runtime &runtime,
+                                               const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkColor>(runtime, value);
+}
+
+template <>
+inline std::optional<BlendModeValue> getPropertyValue(jsi::Runtime &runtime,
+                                                      const jsi::Value &value) {
+  return makeOptionalPropertyValue<BlendModeValue>(runtime, value);
+}
+
+template <>
+inline std::optional<SkBlendMode> getPropertyValue(jsi::Runtime &runtime,
+                                                   const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkBlendMode>(runtime, value);
+}
+
+template <>
+inline std::optional<SkMatrix> getPropertyValue(jsi::Runtime &runtime,
+                                                const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkMatrix>(runtime, value);
+}
+
+template <>
+inline std::optional<SkM44> getPropertyValue(jsi::Runtime &runtime,
+                                             const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkM44>(runtime, value);
+}
+
+template <>
+inline std::optional<bool> getPropertyValue(jsi::Runtime &runtime,
+                                            const jsi::Value &value) {
+  return makeOptionalPropertyValue<bool>(runtime, value);
+}
+
+template <>
+inline std::optional<ClipDef> getPropertyValue(jsi::Runtime &runtime,
+                                               const jsi::Value &value) {
+  return makeOptionalPropertyValue<ClipDef>(runtime, value);
+}
+
+template <>
+inline std::optional<Layer> getPropertyValue(jsi::Runtime &runtime,
+                                             const jsi::Value &value) {
+  return makeOptionalPropertyValue<Layer>(runtime, value);
+}
+
+template <>
+inline std::optional<SkFont> getPropertyValue(jsi::Runtime &runtime,
+                                              const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkFont>(runtime, value);
+}
+
+template <>
+inline std::optional<SkPaint::Style> getPropertyValue(jsi::Runtime &runtime,
+                                                      const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkPaint::Style>(runtime, value);
+}
+
+template <>
+inline std::optional<SkPaint::Join> getPropertyValue(jsi::Runtime &runtime,
+                                                     const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkPaint::Join>(runtime, value);
+}
+
+template <>
+inline std::optional<SkPaint::Cap> getPropertyValue(jsi::Runtime &runtime,
+                                                    const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkPaint::Cap>(runtime, value);
+}
+
+template <>
+inline std::optional<SkRect> getPropertyValue(jsi::Runtime &runtime,
+                                              const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkRect>(runtime, value);
+}
+
+template <>
+inline std::optional<sk_sp<SkImage>> getPropertyValue(jsi::Runtime &runtime,
+                                                      const jsi::Value &value) {
+  return makeOptionalPropertyValue<sk_sp<SkImage>>(runtime, value);
+}
+
+template <>
+inline std::optional<SkSamplingOptions>
+getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkSamplingOptions>(runtime, value);
+}
+
+template <>
+inline std::optional<StrokeOpts> getPropertyValue(jsi::Runtime &runtime,
+                                                  const jsi::Value &value) {
+  return makeOptionalPropertyValue<StrokeOpts>(runtime, value);
+}
+
+template <>
+inline std::optional<std::vector<SkColor>>
+getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  return makeOptionalPropertyValue<std::vector<SkColor>>(runtime, value);
+}
+
+template <>
+inline std::optional<std::vector<float>>
+getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  return makeOptionalPropertyValue<std::vector<float>>(runtime, value);
+}
+
+template <>
+inline std::optional<SkTileMode> getPropertyValue(jsi::Runtime &runtime,
+                                                  const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkTileMode>(runtime, value);
+}
+
+template <>
+inline std::optional<SkPathFillType> getPropertyValue(jsi::Runtime &runtime,
+                                                      const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkPathFillType>(runtime, value);
+}
+
+template <>
+inline std::optional<SkColorChannel> getPropertyValue(jsi::Runtime &runtime,
+                                                      const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkColorChannel>(runtime, value);
+}
+
+template <>
+inline std::optional<Uniforms> getPropertyValue(jsi::Runtime &runtime,
+                                                const jsi::Value &value) {
+  return makeOptionalPropertyValue<Uniforms>(runtime, value);
+}
+
+template <>
+inline std::optional<Radius> getPropertyValue(jsi::Runtime &runtime,
+                                              const jsi::Value &value) {
+  return makeOptionalPropertyValue<Radius>(runtime, value);
+}
+
+template <>
+inline std::optional<SkRRect> getPropertyValue(jsi::Runtime &runtime,
+                                               const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkRRect>(runtime, value);
+}
+
+template <>
+inline std::optional<SkPaint> getPropertyValue(jsi::Runtime &runtime,
+                                               const jsi::Value &value) {
+  return makeOptionalPropertyValue<SkPaint>(runtime, value);
+}
+
+template <>
+inline std::optional<std::vector<SkPoint>>
+getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  return makeOptionalPropertyValue<std::vector<SkPoint>>(runtime, value);
+}
+
+template <>
+inline std::optional<std::vector<uint16_t>>
+getPropertyValue(jsi::Runtime &runtime, const jsi::Value &value) {
+  return makeOptionalPropertyValue<std::vector<uint16_t>>(runtime, value);
+}
+
+} // namespace RNSkia