@react-native-ohos/react-native-clippathview 1.1.9-rc.1

package/harmony/clipPath/src/main/cpp/ClipPathViewNoneNode.h

@@ -0,0 +1,98 @@
+//
+// Created on 2024/6/25.
+//
+// Node APIs are not fully supported. To solve the compilation error of the interface cannot be found,
+// please include "napi/native_api.h".
+#pragma once
+
+#include "RNOH/arkui/ArkUINode.h"
+#include <native_drawing/drawing_matrix.h>
+#include <native_drawing/drawing_pen.h>
+#include <native_drawing/drawing_rect.h>
+#include <native_drawing/drawing_types.h>
+#include "ClipPathProps.h"
+#include "SVGViewBox.h"
+namespace rnoh {
+
+    struct CanvasCallback {
+        std::function<void(ArkUI_NodeCustomEvent *event)> callback;
+    };
+
+    class ClipPathViewNoneNode : public ArkUINode {
+    public:
+        ClipPathViewNoneNode();
+        ~ClipPathViewNoneNode() override;
+        void insertChild(ArkUINode &child, std::size_t index);
+        void removeChild(ArkUINode &child);
+        void setD(const std::string d);
+        void setStrokeWidth(float const width);
+        void setStrokeCap(std::string const cap);
+        void setStrokeJoin(std::string const join);
+        void setStrokeMiter(float const miter);
+        void setStrokeStart(float const start);
+        void setStrokeEnd(float const end);
+        void setViewBox(std::vector<float> viewBox);
+        void setAlign(std::string v);
+        void setAspect(std::string v);
+        void setFillRule(std::string v);
+        // transFrom
+        void setTransX(float v);
+        void setTransY(float v);
+        void setTransPercentageValue(bool v);
+        void setRot(float v);
+        void setRotO(float v);
+        void setRotOx(float v);
+        void setRotOy(float v);
+        void setRotPercentageValue(bool v);
+        void setSc(float v);
+        void setScX(float v);
+        void setScY(float v);
+        void setScO(float v);
+        void setScOx(float v);
+        void setScOy(float v);
+        void setTranslateZ(float z);
+        void setScPercentageValue(bool v);
+ private:
+        void (*eventReceiver)(ArkUI_NodeCustomEvent *event);
+        void OnDraw(ArkUI_NodeCustomEvent *event);
+        void setupPath(OH_Drawing_Canvas *canvas);
+        void viewBoxTransform();
+        bool validateViewBox();
+        void setRect(OH_Drawing_Rect *target, OH_Drawing_Rect *src);
+        void setRectF(OH_Drawing_Rect *target, float left, float top, float right, float bottom);
+        void setPaintStrokeProps();
+        float toDip(float value);
+        void canvasTransform();
+        void drawPath(OH_Drawing_Canvas *canvas);
+        void setPanStyleMode(OH_Drawing_Canvas *canvas,int type);    
+    
+    private:
+        std::string mD{""};
+        std::string mAlign{"xMinYMin"};
+        CanvasCallback *canvasCallback_{nullptr};
+        int mAspect{SVGViewBox::MOS_MEET};
+        ClipPathProps *mProps{new ClipPathProps()};
+        OH_Drawing_Rect *mRectVb{OH_Drawing_RectCreate(0.0f, 0.0f, -1.0f, -1.0f)};
+        OH_Drawing_Rect *mRectVbDensity{OH_Drawing_RectCreate(0.0f, 0.0f, -1.0f, -1.0f)};
+        OH_Drawing_Rect *mRectPath{OH_Drawing_RectCreate(0.0f, 0.0f, 0.0f, 0.0f)};
+        OH_Drawing_Rect *mBounds{OH_Drawing_RectCreate(0.0f, 0.0f, 0.0f, 0.0f)};
+        OH_Drawing_Matrix *mMatrix{OH_Drawing_MatrixCreate()};
+        OH_Drawing_Path *mPath{};
+        OH_Drawing_Path *mPath2{OH_Drawing_PathCreate()};
+        OH_Drawing_Pen *mPaint{OH_Drawing_PenCreate()};
+        OH_Drawing_Pen *mPaintStroke{OH_Drawing_PenCreate()};
+        OH_Drawing_Canvas *canvas{nullptr};
+        float mTranslationX{0.0f};
+        float mTranslationY{0.0f};
+        bool mTranslationIsPercent{false};
+        float mRotation{0.0f};
+        float mRotationOx{0.0f};
+        float mRotationOy{0.0f};
+        bool mRotationIsPercent{false};
+        float mScaleX{1.0f};
+        float mScaleY{1.0f};
+        float mScaleOriginX{0.0f};
+        float mScaleOriginY{0.0f};
+        bool mScaleIsPercent{false};
+    };
+} // namespace rnoh

package/harmony/clipPath/src/main/cpp/ClipPathViewPackage.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HARMONY_CLIP_PATH_VIEW_SRC_MAIN_CPP_CLIPPATHVIEWPACKAGE_H
+#define HARMONY_CLIP_PATH_VIEW_SRC_MAIN_CPP_CLIPPATHVIEWPACKAGE_H
+
+#include "RNCClipPathTurboModule.h"
+#include "RNOH/Package.h"
+#include "ComponentDescriptors.h"
+#include "ClipPathViewNoneJSIBinder.h"
+#include "ClipPathViewNoneNapiBinder.h"
+#include "ClipPathViewJSIBinder.h"
+#include "ClipPathViewNapiBinder.h"
+#include "ClipPathViewNoneComponentInstance.h"
+#include "ClipPathViewComponentInstance.h"
+
+namespace rnoh {
+    class ClipPathViewPackageComponentInstanceFactoryDelegate : public ComponentInstanceFactoryDelegate {
+    public:
+        using ComponentInstanceFactoryDelegate::ComponentInstanceFactoryDelegate;
+
+        ComponentInstance::Shared create(ComponentInstance::Context ctx) override {
+            if (ctx.componentName == "RNCClipPathView") {
+                return std::make_shared<ClipPathViewComponentInstance>(std::move(ctx));
+            } else if (ctx.componentName == "RNCClipPathViewNone") {
+                return std::make_shared<ClipPathViewNoneComponentInstance>(std::move(ctx));
+            }
+            return nullptr;
+        }
+    };
+
+    class RNCClipPathFactoryDelegate : public TurboModuleFactoryDelegate {
+    public:
+        SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {
+            if (name == "RNCClipPathContext") {
+                return std::make_shared<RNCClipPathTurboModule>(ctx, name);
+            }
+            return nullptr;
+        };
+    };
+
+    class ClipPathViewPackage : public Package {
+    public:
+        ClipPathViewPackage(Package::Context ctx) : Package(ctx) {}
+
+        ComponentInstanceFactoryDelegate::Shared createComponentInstanceFactoryDelegate() override {
+            return std::make_shared<ClipPathViewPackageComponentInstanceFactoryDelegate>();
+        }
+
+        std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override {
+            return {facebook::react::concreteComponentDescriptorProvider<
+                facebook::react::RNCClipPathViewNoneComponentDescriptor>()};
+        }
+
+        std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override {
+            return std::make_unique<RNCClipPathFactoryDelegate>();
+        }
+        ComponentJSIBinderByString createComponentJSIBinderByName() override {
+            return {
+                {"RNCClipPathViewNone", std::make_shared<ClipPathViewNoneJSIBinder>()},
+                {"RNCClipPathView", std::make_shared<ClipPathViewJSIBinder>()},
+            };
+        }
+
+        ComponentNapiBinderByString createComponentNapiBinderByName() override {
+            return {
+                {"RNCClipPathViewNone", std::make_shared<ClipPathViewNoneNapiBinder>()},
+                {"RNCClipPathView", std::make_shared<ClipPathViewNapiBinder>()},
+            };
+        }
+    };
+} // namespace rnoh
+#endif

package/harmony/clipPath/src/main/cpp/ComponentDescriptors.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HARMONY_CLIP_PATH_VIEW_SRC_MAIN_CPP_COMPONENTDESCRIPTOR_H
+#define HARMONY_CLIP_PATH_VIEW_SRC_MAIN_CPP_COMPONENTDESCRIPTOR_H
+
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include "ShadowNodes.h"
+
+namespace facebook {
+namespace react {
+
+using RNCClipPathViewComponentDescriptor = ConcreteComponentDescriptor<RNCClipPathViewShadowNode>;
+using RNCClipPathViewNoneComponentDescriptor = ConcreteComponentDescriptor<RNCClipPathViewNoneShadowNode>;
+
+} // namespace react
+} // namespace facebook
+#endif

package/harmony/clipPath/src/main/cpp/ModUtil.cpp

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ModUtil.h"
+#include <native_drawing/drawing_rect.h>
+namespace rnoh {
+float ModUtil::mScreenDensity = 2.5f;
+
+float ModUtil::clamp(float v) { return v > 1 ? 1 : (v < 0 ? 0 : v); }
+
+float ModUtil::uClamp(float v) { return v < 0 ? 0 : v; }
+
+float ModUtil::uClamp(float v, float optional) { return v < 0 ? optional : v; }
+
+float ModUtil::viewBoxEvaluator(float value, float start, float end) { return (value - start) / (end - start); }
+
+float ModUtil::viewBoxToWidth(float value, OH_Drawing_Rect *rectF, float w) {
+    return viewBoxEvaluator(value, OH_Drawing_RectGetLeft(rectF), OH_Drawing_RectGetRight(rectF)) * w;
+}
+
+float ModUtil::viewBoxToHeight(float value, OH_Drawing_Rect *rectF, float h) {
+    return viewBoxEvaluator(value, OH_Drawing_RectGetTop(rectF), OH_Drawing_RectGetBottom(rectF)) * h;
+}
+
+float ModUtil::viewBoxToMax(float value, OH_Drawing_Rect *rectF, float w, float h) {
+    float size = OH_Drawing_RectGetWidth(rectF) > OH_Drawing_RectGetHeight(rectF) ? OH_Drawing_RectGetWidth(rectF)
+                                                                                  : OH_Drawing_RectGetHeight(rectF);
+    float maxVb = w > h ? OH_Drawing_RectGetWidth(rectF) : OH_Drawing_RectGetHeight(rectF);
+    return (value / maxVb) * size;
+}
+void ModUtil::setDensity(float density) { mScreenDensity = density; }
+
+float ModUtil::getDensity() { return mScreenDensity; }
+
+} // namespace rnoh

package/harmony/clipPath/src/main/cpp/ModUtil.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef HARMONY_MODUTIL_H
+#define HARMONY_MODUTIL_H
+#include <native_drawing/drawing_types.h>
+namespace rnoh {
+class ModUtil {
+public:
+    static float clamp(float v);
+    static float uClamp(float v);
+    static float uClamp(float v, float optional);
+    static float viewBoxEvaluator(float value, float start, float end);
+    static float viewBoxToWidth(float value, OH_Drawing_Rect *rectF, float w);
+    static float viewBoxToHeight(float value, OH_Drawing_Rect *rectF, float h);
+    static float viewBoxToMax(float value, OH_Drawing_Rect *rectF, float w, float h);
+    static void setDensity(float density);
+    static float getDensity();
+
+private:
+    static float mScreenDensity;
+};
+
+};     // namespace rnoh
+#endif // HARMONY_MODUTIL_H

package/harmony/clipPath/src/main/cpp/Props.cpp

@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "Props.h"
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook {
+namespace react {
+
+RNCClipPathViewProps::RNCClipPathViewProps(const PropsParserContext &context, const RNCClipPathViewProps &sourceProps,
+                                           const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps), 
+      d(convertRawProp(context, rawProps, "d", sourceProps.d, "/0")),
+      aspect(convertRawProp(context, rawProps, "aspect", sourceProps.aspect, "meet")),
+      fillRule(convertRawProp(context, rawProps, "fillRule", sourceProps.fillRule, "/0")),
+      translateZ(convertRawProp(context, rawProps, "translateZ", sourceProps.translateZ, {0.0})),
+      strokeWidth(convertRawProp(context, rawProps, "strokeWidth", sourceProps.strokeWidth, {1.0})),
+      strokeCap(convertRawProp(context, rawProps, "strokeCap", sourceProps.strokeCap, {"none"})),
+      strokeJoin(convertRawProp(context, rawProps, "strokeJoin", sourceProps.strokeJoin, {"none"})),
+      strokeMiter(convertRawProp(context, rawProps, "strokeMiter", sourceProps.strokeMiter, {4.0})),
+      strokeStart(convertRawProp(context, rawProps, "strokeStart", sourceProps.strokeStart, {0.0})),
+      strokeEnd(convertRawProp(context, rawProps, "strokeEnd", sourceProps.strokeEnd, {1.0})),
+      transX(convertRawProp(context, rawProps, "transX", sourceProps.transX, {0.0})),
+      transY(convertRawProp(context, rawProps, "transY", sourceProps.transY, {0.0})),
+      transPercentageValue(
+          convertRawProp(context, rawProps, "transPercentageValue", sourceProps.transPercentageValue, {false})),
+      rot(convertRawProp(context, rawProps, "rot", sourceProps.rot, {0.0})),
+      rotO(convertRawProp(context, rawProps, "rotO", sourceProps.rotO, {0.0})),
+      rotOx(convertRawProp(context, rawProps, "rotOx", sourceProps.rotOx, {0.0})),
+      rotOy(convertRawProp(context, rawProps, "rotOy", sourceProps.rotOy, {0.0})),
+      rotPercentageValue(
+          convertRawProp(context, rawProps, "rotPercentageValue", sourceProps.rotPercentageValue, {false})),
+      sc(convertRawProp(context, rawProps, "sc", sourceProps.sc, {1.0})),
+
+      scX(convertRawProp(context, rawProps, "scX", sourceProps.scX, {1.0})),
+      scY(convertRawProp(context, rawProps, "scY", sourceProps.scY, {1.0})),
+      scO(convertRawProp(context, rawProps, "scO", sourceProps.scO, {0.0})),
+      scOx(convertRawProp(context, rawProps, "scOx", sourceProps.scOx, {0.0})),
+      scOy(convertRawProp(context, rawProps, "scOy", sourceProps.scOy, {0.0})),
+      scPercentageValue(convertRawProp(context, rawProps, "scPercentageValue", sourceProps.scPercentageValue, {false})),
+
+      align(convertRawProp(context, rawProps, "align", sourceProps.align, {"xMidYMid"})),
+      viewBox(convertRawProp(context, rawProps, "viewBox", sourceProps.viewBox, {})) {}
+
+
+RNCClipPathViewNoneProps::RNCClipPathViewNoneProps(const PropsParserContext &context,
+                                                   const RNCClipPathViewNoneProps &sourceProps,
+                                                   const RawProps &rawProps)
+    : ViewProps(context, sourceProps, rawProps), 
+      d(convertRawProp(context, rawProps, "d", sourceProps.d, "/0")),
+      aspect(convertRawProp(context, rawProps, "aspect", sourceProps.aspect, "meet")),
+      fillRule(convertRawProp(context, rawProps, "fillRule", sourceProps.fillRule, "/0")),
+      translateZ(convertRawProp(context, rawProps, "translateZ", sourceProps.translateZ, {0.0})),
+      strokeWidth(convertRawProp(context, rawProps, "strokeWidth", sourceProps.strokeWidth, {1.0})),
+      strokeCap(convertRawProp(context, rawProps, "strokeCap", sourceProps.strokeCap, {"none"})),
+      strokeJoin(convertRawProp(context, rawProps, "strokeJoin", sourceProps.strokeJoin, {"none"})),
+      strokeMiter(convertRawProp(context, rawProps, "strokeMiter", sourceProps.strokeMiter, {4.0})),
+      strokeStart(convertRawProp(context, rawProps, "strokeStart", sourceProps.strokeStart, {0.0})),
+      strokeEnd(convertRawProp(context, rawProps, "strokeEnd", sourceProps.strokeEnd, {1.0})),
+      transX(convertRawProp(context, rawProps, "transX", sourceProps.transX, {0.0})),
+      transY(convertRawProp(context, rawProps, "transY", sourceProps.transY, {0.0})),
+      transPercentageValue(
+          convertRawProp(context, rawProps, "transPercentageValue", sourceProps.transPercentageValue, {false})),
+      rot(convertRawProp(context, rawProps, "rot", sourceProps.rot, {0.0})),
+      rotO(convertRawProp(context, rawProps, "rotO", sourceProps.rotO, {0.0})),
+      rotOx(convertRawProp(context, rawProps, "rotOx", sourceProps.rotOx, {0.0})),
+      rotOy(convertRawProp(context, rawProps, "rotOy", sourceProps.rotOy, {0.0})),
+      rotPercentageValue(
+          convertRawProp(context, rawProps, "rotPercentageValue", sourceProps.rotPercentageValue, {false})),
+
+      sc(convertRawProp(context, rawProps, "sc", sourceProps.sc, {1.0})),
+      scX(convertRawProp(context, rawProps, "scX", sourceProps.scX, {1.0})),
+      scY(convertRawProp(context, rawProps, "scY", sourceProps.scY, {1.0})),
+      scO(convertRawProp(context, rawProps, "scO", sourceProps.scO, {0.0})),
+      scOx(convertRawProp(context, rawProps, "scOx", sourceProps.scOx, {0.0})),
+      scOy(convertRawProp(context, rawProps, "scOy", sourceProps.scOy, {0.0})),
+      scPercentageValue(convertRawProp(context, rawProps, "scPercentageValue", sourceProps.scPercentageValue, {false})),
+
+      align(convertRawProp(context, rawProps, "align", sourceProps.align, {"xMidYMid"})),
+      viewBox(convertRawProp(context, rawProps, "viewBox", sourceProps.viewBox, {})) {}
+} // namespace react
+} // namespace facebook

package/harmony/clipPath/src/main/cpp/Props.h

@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef HARMONY_CLIP_PATH_VIEW_SRC_MAIN_CPP_PROPS_H
+#define HARMONY_CLIP_PATH_VIEW_SRC_MAIN_CPP_PROPS_H
+
+#include <jsi/jsi.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+
+#include <vector>
+namespace facebook {
+namespace react {
+
+
+class JSI_EXPORT RNCClipPathViewProps final : public ViewProps {
+public:
+    RNCClipPathViewProps() = default;
+    RNCClipPathViewProps(const PropsParserContext &context, const RNCClipPathViewProps &sourceProps,
+                         const RawProps &rawProps);
+
+#pragma mark - Props
+    std::string d;
+    std::string aspect;
+    std::string align{"xMidYMid"};
+    std::string fillRule{"evenodd"};
+    float strokeWidth{1.0};
+    std::string strokeCap{"round"};
+    std::string strokeJoin{"miter"};
+    float strokeMiter{4.0};
+    float strokeStart{0.0};
+    float strokeEnd{1.0};
+
+    float translateZ{0.0f};
+    float transX = 0.f;
+    float transY = 0.f;
+    bool transPercentageValue = false;
+
+    float rot = 0.f;
+    float rotO = 0.f;
+    float rotOx = 0.f;
+    float rotOy = 0.f;
+    bool rotPercentageValue = false;
+
+    float sc = 1.f;
+    float scX = 1.f;
+    float scY = 1.f;
+    float scO = 0.f;
+    float scOx = 0.f;
+    float scOy = 0.f;
+    bool scPercentageValue = false;
+    std::vector<float> viewBox{};
+};
+
+class JSI_EXPORT RNCClipPathViewNoneProps final : public ViewProps {
+public:
+    RNCClipPathViewNoneProps() = default;
+    RNCClipPathViewNoneProps(const PropsParserContext &context, const RNCClipPathViewNoneProps &sourceProps,
+                             const RawProps &rawProps);
+#pragma mark - Props
+    std::string d;
+    std::string aspect;
+    std::string align{"xMidYMid"};
+    std::string fillRule{"evenodd"};
+    float strokeWidth{1.0};
+    std::string strokeCap{"round"};
+    std::string strokeJoin{"miter"};
+    float strokeMiter{4.0};
+    float strokeStart{0.0};
+    float strokeEnd{1.0};
+
+    float translateZ{0.0f};
+    float transX = 0.f;
+    float transY = 0.f;
+    bool transPercentageValue = false;
+
+    float rot = 0.f;
+    float rotO = 0.f;
+    float rotOx = 0.f;
+    float rotOy = 0.f;
+    bool rotPercentageValue = false;
+
+    float sc = 1.f;
+    float scX = 1.f;
+    float scY = 1.f;
+    float scO = 0.f;
+    float scOx = 0.f;
+    float scOy = 0.f;
+    bool scPercentageValue = false;
+    std::vector<float> viewBox{};
+};
+
+} // namespace react
+} // namespace facebook
+#endif

package/harmony/clipPath/src/main/cpp/RNCClipPathTurboModule.cpp

@@ -0,0 +1,38 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "RNCClipPathTurboModule.h"
+
+using namespace rnoh;
+using namespace facebook;
+
+static jsi::Value __hostFunction_RNCClipPathTurboModule_getDensity(jsi::Runtime &rt, react::TurboModule &turboModule,
+                                                                   const jsi::Value *args, size_t count) {
+    return static_cast<ArkTSTurboModule &>(turboModule).call(rt, "getDensity", args, count);
+}
+
+RNCClipPathTurboModule::RNCClipPathTurboModule(const ArkTSTurboModule::Context ctx, const std::string name)
+    : ArkTSTurboModule(ctx, name) {
+    methodMap_["getDensity"] = MethodMetadata{0, __hostFunction_RNCClipPathTurboModule_getDensity};
+}

package/harmony/clipPath/src/main/cpp/RNCClipPathTurboModule.h

@@ -0,0 +1,37 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include "RNOH/ArkTSTurboModule.h"
+
+namespace rnoh {
+
+    class JSI_EXPORT RNCClipPathTurboModule : public ArkTSTurboModule {
+    public:
+        RNCClipPathTurboModule(const ArkTSTurboModule::Context ctx, const std::string name);
+    };
+
+} // namespace rnoh