@react-native-ohos/react-native-svg 15.12.1-rc.1

package/harmony/svg/src/main/cpp/drawing/Pen.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include "ShaderEffect.h"
+#include <memory>
+#include <native_drawing/drawing_pen.h>
+#include <native_drawing/drawing_shader_effect.h>
+
+namespace rnoh::drawing {
+
+class Pen final {
+
+    using UniqueNativePen = std::unique_ptr<OH_Drawing_Pen, decltype(&OH_Drawing_PenDestroy)>;
+
+public:
+    using LineCapStyle = OH_Drawing_PenLineCapStyle;
+    using LineJoinStyle = OH_Drawing_PenLineJoinStyle;
+
+    Pen();
+
+    Pen(Pen const &);
+    Pen &operator=(Pen const &);
+
+    Pen(Pen &&) = default;
+    Pen &operator=(Pen &&) = default;
+
+    ~Pen() noexcept = default;
+
+    void SetAntiAlias(bool antiAlias);
+    void SetColor(uint32_t color);
+    void SetAlpha(uint8_t alpha);
+    void SetWidth(double width);
+    void SetMiterLimit(float miterLimit);
+    void SetLineCap(LineCapStyle lineCap);
+    void SetLineJoin(LineJoinStyle lineJoin);
+    void SetLinearShaderEffect(const OH_Drawing_Point2D *startPt, const OH_Drawing_Point2D *endPt,
+                               const uint32_t *colors, const float *pos, uint32_t size, OH_Drawing_TileMode mode,
+                               const OH_Drawing_Matrix *mat);
+    void SetRadialShaderEffect(const OH_Drawing_Point2D *startPt, float startRadius, const OH_Drawing_Point2D *endPt,
+                               float endRadius, const uint32_t *colors, const float *pos, uint32_t size,
+                               OH_Drawing_TileMode mode, const OH_Drawing_Matrix *mat);
+    void SetImageShaderEffect(OH_Drawing_Image *image, OH_Drawing_TileMode tileX, OH_Drawing_TileMode tileY,
+                              const OH_Drawing_SamplingOptions *opt, const OH_Drawing_Matrix *mat);
+
+    void Reset();
+
+    OH_Drawing_Pen *get() const { return pen_.get(); }
+
+private:
+    UniqueNativePen pen_;
+    ShaderEffect penShaderEffect_;
+};
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/Rect.cpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Rect.h"
+
+namespace rnoh {
+namespace drawing {
+Rect::Rect() : Rect(0, 0, 0, 0) {}
+
+Rect::Rect(float left, float top, float right, float bottom)
+    : rect_(UniqueNativeRect(OH_Drawing_RectCreate(left, top, right, bottom), &OH_Drawing_RectDestroy)) {}
+
+Rect::Rect(Rect const &other) : Rect() { *this = other; }
+Rect &Rect::operator=(Rect const &other) {
+    OH_Drawing_RectCopy(other.get(), get());
+    return *this;
+}
+
+bool Rect::Intersect(const Rect &other) { return OH_Drawing_RectIntersect(get(), other.get()); }
+
+bool Rect::Join(const Rect &other) { return OH_Drawing_RectJoin(get(), other.get()); }
+
+void Rect::SetLeft(float left) { OH_Drawing_RectSetLeft(get(), left); }
+
+void Rect::SetTop(float top) { OH_Drawing_RectSetTop(get(), top); }
+
+void Rect::SetRight(float right) { OH_Drawing_RectSetRight(get(), right); }
+
+void Rect::SetBottom(float bottom) { OH_Drawing_RectSetBottom(get(), bottom); }
+
+float Rect::GetLeft() { return OH_Drawing_RectGetLeft(get()); }
+
+float Rect::GetTop() { return OH_Drawing_RectGetTop(get()); }
+
+float Rect::GetRight() { return OH_Drawing_RectGetRight(get()); }
+
+float Rect::GetBottom() { return OH_Drawing_RectGetBottom(get()); }
+
+float Rect::GetHeight() { return OH_Drawing_RectGetHeight(get()); }
+
+float Rect::GetWidth() { return OH_Drawing_RectGetWidth(get()); }
+
+} // namespace drawing
+} // namespace rnoh

package/harmony/svg/src/main/cpp/drawing/Rect.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <memory>
+#include <native_drawing/drawing_rect.h>
+
+namespace rnoh {
+namespace drawing {
+class Rect final {
+    using UniqueNativeRect = std::unique_ptr<OH_Drawing_Rect, decltype(&OH_Drawing_RectDestroy)>;
+
+public:
+    Rect();
+    Rect(float left, float top, float right, float bottom);
+    Rect(Rect const &);
+    Rect &operator=(Rect const &);
+    Rect(Rect &&) = default;
+    Rect &operator=(Rect &&) = default;
+    ~Rect() noexcept = default;
+
+    bool Intersect(const Rect &other);
+
+    bool Join(const Rect &other);
+
+    void SetLeft(float left);
+
+    void SetTop(float top);
+
+    void SetRight(float right);
+
+    void SetBottom(float bottom);
+
+    float GetLeft();
+
+    float GetTop();
+
+    float GetRight();
+
+    float GetBottom();
+
+    float GetHeight();
+
+    float GetWidth();
+
+    OH_Drawing_Rect *get() const { return rect_.get(); }
+
+private:
+    UniqueNativeRect rect_;
+};
+} // namespace drawing
+} // namespace rnoh

package/harmony/svg/src/main/cpp/drawing/RoundRect.cpp

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "RoundRect.h"
+
+namespace rnoh {
+namespace drawing {
+
+RoundRect::RoundRect(Rect rect, float rx, float ry)
+    : rect_(std::move(rect)),
+      roundRect_(UniqueNativeRoundRect(OH_Drawing_RoundRectCreate(rect_.get(), rx, ry), &OH_Drawing_RoundRectDestroy)) {
+}
+void RoundRect::SetCorner(CornerPos pos, CornerRadii radii) {
+    OH_Drawing_RoundRectSetCorner(roundRect_.get(), pos, radii);
+}
+RoundRect::CornerRadii RoundRect::GetCorner(CornerPos pos) {
+    return OH_Drawing_RoundRectGetCorner(roundRect_.get(), pos);
+}
+
+} // namespace drawing
+} // namespace rnoh

package/harmony/svg/src/main/cpp/drawing/RoundRect.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <memory>
+#include <native_drawing/drawing_round_rect.h>
+#include "Rect.h"
+
+namespace rnoh {
+namespace drawing {
+class RoundRect final {
+    using UniqueNativeRoundRect = std::unique_ptr<OH_Drawing_RoundRect, decltype(&OH_Drawing_RoundRectDestroy)>;
+
+    using CornerPos = OH_Drawing_CornerPos;
+    using CornerRadii = OH_Drawing_Corner_Radii;
+
+public:
+    RoundRect(Rect rect, float rx, float ry);
+    RoundRect(RoundRect const &) = delete;
+    RoundRect &operator=(RoundRect const &) = delete;
+    RoundRect(RoundRect &&) = default;
+    RoundRect &operator=(RoundRect &&) = default;
+    ~RoundRect() noexcept = default;
+
+    void SetCorner(CornerPos pos, CornerRadii radii);
+    CornerRadii GetCorner(CornerPos pos);
+
+    OH_Drawing_RoundRect *get() const { return roundRect_.get(); }
+
+private:
+    Rect rect_;
+    UniqueNativeRoundRect roundRect_;
+};
+} // namespace drawing
+} // namespace rnoh

package/harmony/svg/src/main/cpp/drawing/ShaderEffect.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "ShaderEffect.h"
+
+namespace rnoh::drawing {
+
+ShaderEffect::ShaderEffect() : shaderEffect_(UniqueNativeShaderEffect(nullptr, &OH_Drawing_ShaderEffectDestroy)) {}
+
+void ShaderEffect::ShaderEffectCreateLinearGradient(const OH_Drawing_Point2D *startPt, const OH_Drawing_Point2D *endPt,
+                                                    const uint32_t *colors, const float *pos, uint32_t size,
+                                                    OH_Drawing_TileMode mode, const OH_Drawing_Matrix *mat) {
+    shaderEffect_ = UniqueNativeShaderEffect(
+        OH_Drawing_ShaderEffectCreateLinearGradientWithLocalMatrix(startPt, endPt, colors, pos, size, mode, mat),
+        &OH_Drawing_ShaderEffectDestroy);
+}
+
+void ShaderEffect::ShaderEffectCreateRadialGradient(const OH_Drawing_Point2D *startPt, float startRadius,
+                                                    const OH_Drawing_Point2D *endPt, float endRadius,
+                                                    const uint32_t *colors, const float *pos, uint32_t size,
+                                                    OH_Drawing_TileMode mode, const OH_Drawing_Matrix *mat) {
+    shaderEffect_ = UniqueNativeShaderEffect(OH_Drawing_ShaderEffectCreateTwoPointConicalGradient(
+                                                 startPt, startRadius, endPt, endRadius, colors, pos, size, mode, mat),
+                                             &OH_Drawing_ShaderEffectDestroy);
+}
+
+void ShaderEffect::ShaderEffectCreateImageShader(OH_Drawing_Image *image, OH_Drawing_TileMode tileX,
+                                                 OH_Drawing_TileMode tileY, const OH_Drawing_SamplingOptions *opt,
+                                                 const OH_Drawing_Matrix *mat) {
+    shaderEffect_ = UniqueNativeShaderEffect(OH_Drawing_ShaderEffectCreateImageShader(image, tileX, tileY, opt, mat),
+                                             &OH_Drawing_ShaderEffectDestroy);
+}
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/ShaderEffect.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <memory>
+#include <native_drawing/drawing_shader_effect.h>
+#include <native_drawing/drawing_point.h>
+#include <native_drawing/drawing_matrix.h>
+#include <native_drawing/drawing_types.h>
+
+namespace rnoh::drawing {
+
+class ShaderEffect final {
+
+    using UniqueNativeShaderEffect =
+        std::unique_ptr<OH_Drawing_ShaderEffect, decltype(&OH_Drawing_ShaderEffectDestroy)>;
+
+public:
+    ShaderEffect();
+
+    ShaderEffect(ShaderEffect const &other) = delete;
+    ShaderEffect &operator=(ShaderEffect const &other) = delete;
+
+    ShaderEffect(ShaderEffect &&other) = default;
+    ShaderEffect &operator=(ShaderEffect &&other) = default;
+
+    void ShaderEffectCreateLinearGradient(const OH_Drawing_Point2D *startPt, const OH_Drawing_Point2D *endPt,
+                                          const uint32_t *colors, const float *pos, uint32_t size,
+                                          OH_Drawing_TileMode mode, const OH_Drawing_Matrix *mat);
+
+    void ShaderEffectCreateRadialGradient(const OH_Drawing_Point2D *startPt, float startRadius,
+                                          const OH_Drawing_Point2D *endPt, float endRadius, const uint32_t *colors,
+                                          const float *pos, uint32_t size, OH_Drawing_TileMode mode,
+                                          const OH_Drawing_Matrix *mat);
+
+    void ShaderEffectCreateImageShader(OH_Drawing_Image *image, OH_Drawing_TileMode tileX, OH_Drawing_TileMode tileY,
+                                       const OH_Drawing_SamplingOptions *opt, const OH_Drawing_Matrix *mat);
+
+    ~ShaderEffect() noexcept = default;
+
+    OH_Drawing_ShaderEffect *get() const { return shaderEffect_.get(); }
+
+private:
+    UniqueNativeShaderEffect shaderEffect_;
+};
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/TextStyle.cpp

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "TextStyle.h"
+
+namespace rnoh::drawing {
+static std::vector<std::string> disableDiscretionaryLigatures = {"liga", "clig", "dlig", "hlig", "cala"};
+static std::vector<std::string> defaultFeatures = {"rlig", "liga", "clig", "calt", "locl",
+                                                   "ccmp", "mark", "mkmk", "kern"};
+static std::vector<std::string> additionalLigatures = {"hlig", "cala"};
+static std::string fontWeightTag = "wght";
+
+TextStyle::TextStyle() : textStyle_(UniqueTextStyle(OH_Drawing_CreateTextStyle(), OH_Drawing_DestroyTextStyle)) {}
+
+void TextStyle::Update(const std::shared_ptr<svg::FontData> &style) {
+    auto *ts = textStyle_.get();
+    OH_Drawing_SetTextStyleFontSize(ts, style->fontSize);
+    OH_Drawing_SetTextStyleFontWeight(ts, static_cast<int>(style->fontWeight));
+    OH_Drawing_SetTextStyleFontStyle(ts, static_cast<int>(style->fontStyle));
+    if (!style->fontFamily.empty()) {
+        std::vector<const char *> ff{style->fontFamily.c_str()};
+        OH_Drawing_SetTextStyleFontFamilies(ts, 1, ff.data());
+    }
+    OH_Drawing_SetTextStyleDecoration(ts, static_cast<int>(style->textDecoration));
+    OH_Drawing_SetTextStyleLetterSpacing(ts, style->letterSpacing);
+    OH_Drawing_SetTextStyleWordSpacing(ts, style->wordSpacing);
+
+    for (const auto &key : defaultFeatures) {
+        OH_Drawing_TextStyleAddFontFeature(ts, key.c_str(), 1);
+    }
+    OH_Drawing_TextStyleAddFontFeature(ts, style->fontFeatureSettings.c_str(), 1);
+
+    const bool allowOptionalLigatures =
+        style->letterSpacing == 0 && style->fontVariantLigatures == svg::FontVariantLigatures::normal;
+    if (allowOptionalLigatures) {
+        for (const auto &key : additionalLigatures) {
+            OH_Drawing_TextStyleAddFontFeature(ts, key.c_str(), 1);
+        }
+    } else {
+        for (const auto &key : disableDiscretionaryLigatures) {
+            OH_Drawing_TextStyleAddFontFeature(ts, key.c_str(), 0);
+        }
+    }
+}
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/TextStyle.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <memory>
+#include <native_drawing/drawing_text_typography.h>
+#include "properties/Font.h"
+
+namespace rnoh::drawing {
+
+class TextStyle final {
+
+    using UniqueTextStyle = std::unique_ptr<OH_Drawing_TextStyle, decltype(&OH_Drawing_DestroyTextStyle)>;
+
+public:
+    TextStyle();
+    ~TextStyle() noexcept = default;
+
+    TextStyle(const TextStyle &) = delete;
+    TextStyle &operator=(const TextStyle &) = delete;
+
+    TextStyle(TextStyle &&) = default;
+    TextStyle &operator=(TextStyle &&) = default;
+
+    void SetForegroundPen(OH_Drawing_Pen *pen) { OH_Drawing_SetTextStyleForegroundPen(textStyle_.get(), pen); }
+
+    void SetForegroundBrush(OH_Drawing_Brush *brush) {
+        OH_Drawing_SetTextStyleForegroundBrush(textStyle_.get(), brush);
+    }
+
+    void Update(const std::shared_ptr<svg::FontData> &style);
+// private:
+    UniqueTextStyle textStyle_;
+    friend class TypographyStyle;
+};
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/Typography.cpp

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "Typography.h"
+
+// NO-OP

package/harmony/svg/src/main/cpp/drawing/Typography.h

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <native_drawing/drawing_text_typography.h>
+#include "TypographyStyle.h"
+
+namespace rnoh::drawing {
+
+class Typography {
+public:
+    Typography(OH_Drawing_TypographyCreate *handler)
+        : typ_(TypUPtr(OH_Drawing_CreateTypography(handler), OH_Drawing_DestroyTypography)) {}
+    OH_Drawing_Typography *operator&() { return typ_.get(); }
+
+private:
+    using TypUPtr = std::unique_ptr<OH_Drawing_Typography, decltype(&OH_Drawing_DestroyTypography)>;
+    TypUPtr typ_;
+};
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/TypographyStyle.cpp

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#include "TypographyStyle.h"
+#include <native_drawing/drawing_text_typography.h>
+
+namespace rnoh::drawing {
+
+TypographyStyle::TypographyStyle()
+    : typographyStyle_(UniqueTypographyStyle(OH_Drawing_CreateTypographyStyle(), OH_Drawing_DestroyTypographyStyle)) {}
+
+TypographyStyle::~TypographyStyle() noexcept {}
+
+void TypographyStyle::SetTextStyle(TextStyle textStyle) {
+    textStyle_ = std::move(textStyle.textStyle_);
+    OH_Drawing_SetTypographyTextStyle(typographyStyle_.get(), textStyle_.get());
+}
+
+void TypographyStyle::Update(const std::shared_ptr<svg::FontData> &style) {
+    auto *ts = typographyStyle_.get();
+    OH_Drawing_SetTypographyTextFontWeight(ts, style->absoluteFontWeight);
+    OH_Drawing_SetTypographyTextFontStyle(ts, static_cast<int>(style->fontStyle));
+    OH_Drawing_SetTypographyTextFontFamily(ts, style->fontFamily.c_str());
+    OH_Drawing_SetTypographyTextFontSize(ts, style->fontSize);
+    // to be done? TypographyTextAlign
+}
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/drawing/TypographyStyle.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <native_drawing/drawing_text_typography.h>
+
+#include "TextStyle.h"
+#include "properties/Font.h"
+
+namespace rnoh::drawing {
+
+class TypographyStyle final {
+
+    using UniqueTypographyStyle =
+        std::unique_ptr<OH_Drawing_TypographyStyle, decltype(&OH_Drawing_DestroyTypographyStyle)>;
+
+public:
+    TypographyStyle();
+    ~TypographyStyle() noexcept;
+
+    TypographyStyle(const TypographyStyle &) = delete;
+    TypographyStyle &operator=(const TypographyStyle &) = delete;
+
+    TypographyStyle(TypographyStyle &&other) = default;
+    TypographyStyle &operator=(TypographyStyle &&other) = default;
+
+    void SetTextStyle(TextStyle textStyle);
+
+    void Update(const std::shared_ptr<svg::FontData> &style);
+
+    UniqueTypographyStyle typographyStyle_;
+    TextStyle::UniqueTextStyle textStyle_ = {nullptr, OH_Drawing_DestroyTextStyle};
+};
+
+} // namespace rnoh::drawing

package/harmony/svg/src/main/cpp/generated/RNOH/generated/components/RNSVGCircleJSIBinder.h

@@ -0,0 +1,54 @@
+#pragma once
+
+// This file was generated.
+
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class RNSVGCircleJSIBinder : public ViewComponentJSIBinder {
+  protected:
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "name", true);
+        object.setProperty(rt, "opacity", true);
+        object.setProperty(rt, "matrix", true);
+        object.setProperty(rt, "mask", true);
+        object.setProperty(rt, "markerStart", true);
+        object.setProperty(rt, "markerMid", true);
+        object.setProperty(rt, "markerEnd", true);
+        object.setProperty(rt, "clipPath", true);
+        object.setProperty(rt, "clipRule", true);
+        object.setProperty(rt, "filter", true);
+        object.setProperty(rt, "responsible", true);
+        object.setProperty(rt, "display", true);
+        object.setProperty(rt, "pointerEvents", true);
+        object.setProperty(rt, "fill", "Object");
+        object.setProperty(rt, "fillOpacity", true);
+        object.setProperty(rt, "fillRule", true);
+        object.setProperty(rt, "stroke", "Object");
+        object.setProperty(rt, "strokeOpacity", true);
+        object.setProperty(rt, "strokeWidth", true);
+        object.setProperty(rt, "strokeLinecap", true);
+        object.setProperty(rt, "strokeLinejoin", true);
+        object.setProperty(rt, "strokeDasharray", true);
+        object.setProperty(rt, "strokeDashoffset", true);
+        object.setProperty(rt, "strokeMiterlimit", true);
+        object.setProperty(rt, "vectorEffect", true);
+        object.setProperty(rt, "propList", true);
+        object.setProperty(rt, "cx", true);
+        object.setProperty(rt, "cy", true);
+        object.setProperty(rt, "r", true);
+        return object;
+    }
+
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+};
+} // namespace rnoh

package/harmony/svg/src/main/cpp/generated/RNOH/generated/components/RNSVGClipPathJSIBinder.h

@@ -0,0 +1,54 @@
+#pragma once
+
+// This file was generated.
+
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class RNSVGClipPathJSIBinder : public ViewComponentJSIBinder {
+  protected:
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "name", true);
+        object.setProperty(rt, "opacity", true);
+        object.setProperty(rt, "matrix", true);
+        object.setProperty(rt, "mask", true);
+        object.setProperty(rt, "markerStart", true);
+        object.setProperty(rt, "markerMid", true);
+        object.setProperty(rt, "markerEnd", true);
+        object.setProperty(rt, "clipPath", true);
+        object.setProperty(rt, "clipRule", true);
+        object.setProperty(rt, "filter", true);
+        object.setProperty(rt, "responsible", true);
+        object.setProperty(rt, "display", true);
+        object.setProperty(rt, "pointerEvents", true);
+        object.setProperty(rt, "fill", "Object");
+        object.setProperty(rt, "fillOpacity", true);
+        object.setProperty(rt, "fillRule", true);
+        object.setProperty(rt, "stroke", "Object");
+        object.setProperty(rt, "strokeOpacity", true);
+        object.setProperty(rt, "strokeWidth", true);
+        object.setProperty(rt, "strokeLinecap", true);
+        object.setProperty(rt, "strokeLinejoin", true);
+        object.setProperty(rt, "strokeDasharray", true);
+        object.setProperty(rt, "strokeDashoffset", true);
+        object.setProperty(rt, "strokeMiterlimit", true);
+        object.setProperty(rt, "vectorEffect", true);
+        object.setProperty(rt, "propList", true);
+        object.setProperty(rt, "fontSize", true);
+        object.setProperty(rt, "fontWeight", true);
+        object.setProperty(rt, "font", "Object");
+        return object;
+    }
+
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+};
+} // namespace rnoh

package/harmony/svg/src/main/cpp/generated/RNOH/generated/components/RNSVGDefsJSIBinder.h

@@ -0,0 +1,38 @@
+#pragma once
+
+// This file was generated.
+
+#include "RNOHCorePackage/ComponentBinders/ViewComponentJSIBinder.h"
+
+namespace rnoh {
+class RNSVGDefsJSIBinder : public ViewComponentJSIBinder {
+  protected:
+    facebook::jsi::Object createNativeProps(facebook::jsi::Runtime &rt) override {
+        auto object = ViewComponentJSIBinder::createNativeProps(rt);
+        object.setProperty(rt, "name", true);
+        object.setProperty(rt, "opacity", true);
+        object.setProperty(rt, "matrix", true);
+        object.setProperty(rt, "mask", true);
+        object.setProperty(rt, "markerStart", true);
+        object.setProperty(rt, "markerMid", true);
+        object.setProperty(rt, "markerEnd", true);
+        object.setProperty(rt, "clipPath", true);
+        object.setProperty(rt, "clipRule", true);
+        object.setProperty(rt, "filter", true);
+        object.setProperty(rt, "responsible", true);
+        object.setProperty(rt, "display", true);
+        object.setProperty(rt, "pointerEvents", true);
+        return object;
+    }
+
+    facebook::jsi::Object createBubblingEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+
+    facebook::jsi::Object createDirectEventTypes(facebook::jsi::Runtime &rt) override {
+        facebook::jsi::Object events(rt);
+        return events;
+    }
+};
+} // namespace rnoh