@amazon-devices/expo-linear-gradient 2.0.1758683737

package/ios/LinearGradientView.swift

@@ -0,0 +1,14 @@
+// Copyright 2021-present 650 Industries. All rights reserved.
+
+import UIKit
+import ExpoModulesCore
+
+final class LinearGradientView: ExpoView {
+  override class var layerClass: AnyClass {
+    return LinearGradientLayer.self
+  }
+
+  public var gradientLayer: LinearGradientLayer {
+    return layer as! LinearGradientLayer
+  }
+}

package/kepler/ExpoLinearGradientDrawableLayer.cpp

@@ -0,0 +1,85 @@
+//
+// Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All rights reserved.
+//
+#include "ExpoLinearGradientDrawableLayer.h"
+
+#include <KeplerScript/logger/KPLog.h>
+#include <graphics/AutoCanvasRestore.h>
+#include <graphics/Color.h>
+#include <graphics/Paint.h>
+
+#include <optional>
+
+namespace volta {
+namespace react {
+
+void ExpoLinearGradientDrawableLayer::onDraw(volta::graphics::Canvas& canvas) {
+    calculateGradient();
+    volta::graphics::Paint paint{};
+    paint.setShader(linearGradientShader_);
+    paint.setStyle(volta::graphics::Paint::Style::Fill);
+    paint.setAntiAlias(true);
+
+    if (!path_.isEmpty()) {
+        canvas.drawPath(path_, paint);
+    } else if (!rect_.empty()) {
+        canvas.drawRect(rect_, paint);
+    }
+}
+
+void ExpoLinearGradientDrawableLayer::setColors(const std::vector<uint32_t> colors) {
+    colors_ = colors;
+}
+
+void ExpoLinearGradientDrawableLayer::setStart(const graphics::Point& start) {
+    start_ = start;
+}
+
+void ExpoLinearGradientDrawableLayer::setEnd(const graphics::Point& end) {
+    end_ = end;
+}
+
+void ExpoLinearGradientDrawableLayer::setLocations(const std::vector<float>& locations) {
+    locations_ = locations;
+}
+
+void ExpoLinearGradientDrawableLayer::setRect(const volta::graphics::Rect& rect) {
+    rect_ = rect;
+    setDimensions({rect.right(), rect.bottom()});
+}
+
+void ExpoLinearGradientDrawableLayer::setPath(const volta::graphics::Path& path) {
+    path_ = path;
+}
+
+void ExpoLinearGradientDrawableLayer::setSize(const float width, const float height) {
+    size_.set(width, height);
+}
+
+void ExpoLinearGradientDrawableLayer::calculateGradient() {
+    // guard against crashes happening while multiple properties are updated
+    const bool noColors = colors_.empty();
+    const bool mismatchedLocationsWithColors = !locations_.empty() && colors_.size() != locations_.size();
+    if (noColors || mismatchedLocationsWithColors) return;
+
+    const graphics::Point startPos = graphics::Point{start_.x() * size_.x(), start_.y() * size_.y()};
+    const graphics::Point endPos = graphics::Point{end_.x() * size_.x(), end_.y() * size_.y()};
+
+    if (!locations_.empty()) {
+        linearGradientShader_ = volta::graphics::LinearGradientShader::makeLinearGradientShader(
+                startPos,
+                endPos,
+                colors_,
+                locations_,
+                volta::graphics::TileMode::Clamp);
+    } else {
+        linearGradientShader_ = volta::graphics::LinearGradientShader::makeLinearGradientShader(
+                startPos,
+                endPos,
+                colors_,
+                volta::graphics::TileMode::Clamp);
+    }
+}
+
+}  // namespace react
+}  // namespace volta

package/kepler/ExpoLinearGradientDrawableLayer.h

@@ -0,0 +1,81 @@
+//
+// Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All rights reserved.
+//
+#pragma once
+
+#include <JsonContainer/JsonContainer.h>
+#include <graphics/DrawableLayer.h>
+#include <graphics/Path.h>
+#include <graphics/Point.h>
+#include <graphics/Rect.h>
+#include <graphics/Shader.h>
+
+namespace volta {
+namespace react {
+
+class ExpoLinearGradientDrawableLayer final : public volta::graphics::DrawableLayer {
+public:
+    void onDraw(volta::graphics::Canvas& canvas) override;
+    void setColors(const std::vector<uint32_t> colors);
+    void setStart(const graphics::Point& start);
+    void setEnd(const graphics::Point& end);
+    void setLocations(const std::vector<float>& locations);
+    void setRect(const volta::graphics::Rect& rect);
+    void setPath(const volta::graphics::Path& path);
+    void setSize(const float width, const float height);
+
+#ifndef UNIT_TEST
+private:
+#endif
+    /**
+     * @brief Calculate the gradientShader value using startPoint, endPoint, locations etc.
+     */
+    void calculateGradient();
+
+    graphics::Point size_ = {0, 0};
+    volta::graphics::Rect rect_;
+    volta::graphics::Path path_;
+    std::shared_ptr<graphics::Shader> linearGradientShader_;
+
+    /**
+     * An array of colors that represent stops in the gradient. At least two colors are required
+     * (for a single-color background, use the `style.backgroundColor` prop on a `View` component).
+     */
+    std::vector<uint32_t> colors_;
+
+    /**
+     * For example, `{ x: 0.1, y: 0.2 }` means that the gradient will start `10%` from the left and `20%` from the top.
+     *
+     * **On web**, this only changes the angle of the gradient because CSS gradients don't support changing the starting
+     * position.
+     * @default { x: 0.5, y: 0.0 }
+     */
+    graphics::Point start_ = {0.5, 0};
+
+    /**
+     * For example, `{ x: 0.1, y: 0.2 }` means that the gradient will end `10%` from the left and `20%` from the bottom.
+     *
+     * **On web**, this only changes the angle of the gradient because CSS gradients don't support changing the end
+     * position.
+     * @default { x: 0.5, y: 1.0 }
+     */
+    graphics::Point end_ = {0.5, 1};
+
+    /**
+     * An array that contains `number`s ranging from `0` to `1`, inclusive, and is the same length as the `colors`
+     * property. Each number indicates a color-stop location where each respective color should be located. If not
+     * specified, the colors will be distributed evenly across the gradient.
+     *
+     * For example, `[0.5, 0.8]` would render:
+     * - the first color, solid, from the beginning of the gradient view to 50% through (the middle);
+     * - a gradient from the first color to the second from the 50% point to the 80% point; and
+     * - the second color, solid, from the 80% point to the end of the gradient view.
+     *
+     * > The color-stop locations must be ascending from least to greatest.
+     * @default []
+     */
+    std::vector<float> locations_;
+};
+
+}  // namespace react
+}  // namespace volta

package/kepler/ExpoLinearGradientView.cpp

@@ -0,0 +1,92 @@
+//
+// Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All rights reserved.
+//
+#include "ExpoLinearGradientView.h"
+
+#include <KeplerScript/logger/KPLog.h>
+#include <graphics/Color.h>
+#include <graphics/Point.h>
+
+#include <utility>
+
+namespace {
+
+template<typename T = float>
+std::vector<T> toVector(const utils::json::JsonContainer& json) {
+    auto container = utils::json::JsonContainer(json);
+    const bool isArray = container.getType() == utils::json::JsonContainer::Type::ARRAY;
+
+    if (isArray) {
+        return container.getValuesToVector<T>();
+    }
+    return {};
+}
+
+}  // namespace
+
+namespace volta {
+namespace react {
+
+ExpoLinearGradientView::ExpoLinearGradientView() {
+    opacityLayer_.removeAllChildren();
+    opacityLayer_.addChild(linearGradientDrawableLayer_);
+    opacityLayer_.addChild(borderDrawableLayer_);
+    opacityLayer_.addChild(clipRRectLayer_);
+}
+
+void ExpoLinearGradientView::setColors(const utils::json::JsonContainer& newValue) {
+    const auto vector = toVector<double>(newValue);
+    std::vector<uint32_t> colors(vector.size());
+    for (size_t i = 0; i < vector.size(); i++) {
+        colors[i] = graphics::Color(vector[i]).argb();
+    }
+
+    linearGradientDrawableLayer_.setColors(colors);
+}
+
+void ExpoLinearGradientView::setStart(const utils::json::JsonContainer& newValue) {
+    const auto vector = toVector(newValue);
+    if (vector.size() != 2) {
+        KPLog.warn("Parameter passed to ExpoLinearGradientView::setStart must contain 2 values and has {}", vector.size());
+        return;
+    }
+
+    linearGradientDrawableLayer_.setStart(graphics::Point{vector[0], vector[1]});
+}
+
+void ExpoLinearGradientView::setEnd(const utils::json::JsonContainer& newValue) {
+    const auto vector = toVector(newValue);
+    if (vector.size() != 2) {
+        KPLog.warn("Parameter passed to ExpoLinearGradientView::setEnd must contain 2 values and has {}", vector.size());
+        return;
+    }
+
+    linearGradientDrawableLayer_.setEnd(graphics::Point{vector[0], vector[1]});
+}
+
+void ExpoLinearGradientView::setLocations(const utils::json::JsonContainer& newValue) {
+    const auto locations = toVector(newValue);
+    linearGradientDrawableLayer_.setLocations(locations);
+}
+
+void ExpoLinearGradientView::updateLayoutMetrics(
+        const std::shared_ptr<KeplerViewComponentLayoutMetrics>& oldLayoutMetrics,
+        const std::shared_ptr<KeplerViewComponentLayoutMetrics>& newLayoutMetrics) {
+    if (oldLayoutMetrics == newLayoutMetrics) return;
+
+    KeplerViewComponent::updateLayoutMetrics(oldLayoutMetrics, newLayoutMetrics);
+
+    auto& topLeftCorner = borderDrawableLayer_.getBorderCalculatedMetrics().innerTopLeftCorner();
+    auto& bottomRightCorner = borderDrawableLayer_.getBorderCalculatedMetrics().innerBottomRightCorner();
+
+    linearGradientDrawableLayer_.setRect({topLeftCorner, bottomRightCorner});
+    linearGradientDrawableLayer_.setPath(
+            borderDrawableLayer_.getBorderCalculatedMetrics().innerClipPathForBorderRadius());
+    linearGradientDrawableLayer_.setSize(
+            bottomRightCorner.x() - topLeftCorner.x(),
+            bottomRightCorner.y() - topLeftCorner.y());
+    linearGradientDrawableLayer_.invalidate();
+}
+
+}  // namespace react
+}  // namespace volta

package/kepler/ExpoLinearGradientView.h

@@ -0,0 +1,37 @@
+//
+// Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All rights reserved.
+//
+
+#pragma once
+
+#include <KeplerScript/components/KeplerViewComponent.h>
+
+#include "ExpoLinearGradientDrawableLayer.h"
+
+namespace volta {
+namespace react {
+
+class ExpoLinearGradientView : public KeplerViewComponent {
+public:
+    ExpoLinearGradientView();
+    void setColors(const utils::json::JsonContainer& newValue);
+    void setStart(const utils::json::JsonContainer& newValue);
+    void setEnd(const utils::json::JsonContainer& newValue);
+    void setLocations(const utils::json::JsonContainer& newValue);
+
+#ifndef UNIT_TEST
+protected:
+#endif
+    void updateLayoutMetrics(
+            const std::shared_ptr<KeplerViewComponentLayoutMetrics>& oldLayoutMetrics,
+            const std::shared_ptr<KeplerViewComponentLayoutMetrics>& newLayoutMetrics) override;
+
+private:
+#ifdef UNIT_TEST
+public:
+#endif
+    ExpoLinearGradientDrawableLayer linearGradientDrawableLayer_;
+};
+
+}  // namespace react
+}  // namespace volta

package/kepler/ExpoLinearGradientViewManager.cpp

@@ -0,0 +1,28 @@
+//
+// Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All rights reserved.
+//
+
+#include "ExpoLinearGradientViewManager.h"
+
+#include <Volta/trace/Tracing.h>
+
+#include "ExpoLinearGradientView.h"
+
+namespace volta {
+namespace react {
+
+std::shared_ptr<KeplerViewComponent> ExpoLinearGradientViewManager::createComponentView() {
+    VOLTA_TRACE_SECTION(ExpoLinearGradientViewManager::createComponentView);
+    return RenderObject::create<ExpoLinearGradientView>();
+}
+
+void ExpoLinearGradientViewManager::aggregatePropSetters(PropSetterAggregator& aggregator) {
+    ViewComponentViewManager::aggregatePropSetters(aggregator);
+    aggregator.addPropSetter("colors", &ExpoLinearGradientView::setColors, utils::json::JsonContainer());
+    aggregator.addPropSetter("startPoint", &ExpoLinearGradientView::setStart, utils::json::JsonContainer());
+    aggregator.addPropSetter("endPoint", &ExpoLinearGradientView::setEnd, utils::json::JsonContainer());
+    aggregator.addPropSetter("locations", &ExpoLinearGradientView::setLocations, utils::json::JsonContainer());
+}
+
+}  // namespace react
+}  // namespace volta

package/kepler/ExpoLinearGradientViewManager.h

@@ -0,0 +1,19 @@
+//
+// Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All rights reserved.
+//
+
+#pragma once
+
+#include <KeplerScript/components/ViewComponentViewManager.h>
+
+namespace volta {
+namespace react {
+
+class ExpoLinearGradientViewManager : public ViewComponentViewManager {
+public:
+    void aggregatePropSetters(PropSetterAggregator& aggregator) override;
+    std::shared_ptr<KeplerViewComponent> createComponentView() override;
+};
+
+}  // namespace react
+}  // namespace volta

package/kepler/KeplerInit.cpp

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include <KeplerScript/utils/autolink/KeplerAutoLinkInfo.h>
+#include <keplerui-072/keplerscript-export.h>
+
+#include "ExpoLinearGradientViewManager.h"
+
+extern "C" {
+KEPLERSCRIPT_EXPORT void keplerAutoLinkInitV1(const kepler::autolink::v1::KeplerAutoLinkInfo* autoLinkInfo) noexcept {
+    volta::react::KPLog.debug("keplerAutoLinkInitV1 for ExpoLinearGradient");
+
+    autoLinkInfo->customViewManagerDelegate->registerComponentViewManager("ExpoLinearGradient", []() {
+        volta::react::KPLog.debug("registerComponentViewManager {}", "ExpoLinearGradient");
+
+        return std::make_unique<volta::react::ExpoLinearGradientViewManager>();
+    });
+}
+}
+
+int main() {
+    return 0;
+}

package/kepler/test/ExpoLinearGradientDrawableLayer.cpp

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "catch.hpp"
+
+#include "../ExpoLinearGradientDrawableLayer.h"
+
+using namespace volta::react;
+
+TEST_CASE("ExpoLinearGradientDrawableLayer") {
+    std::vector<uint32_t> colors{0xFF0000, 0x00FF00, 0x0000FF};
+    std::vector<float> locations{10, 20, 30};
+    volta::graphics::Point point1{1, 2};
+    volta::graphics::Point point2{4, 6};
+    volta::graphics::Rect rect{point1, point2};
+    volta::graphics::Path path;
+    path.addRect(rect);
+
+    // TODO: PROJVEGA-211833 - Fix these test cases - removing volta::graphics::Canvas mocks
+    // SECTION("Test ExpoLinearGradientDrawableLayer::onDraw - No metrics set") {
+    //     ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+    //     volta::graphics::Canvas canvas{};
+    //     EXPECT_CALL(canvas, drawPath(::testing::_, ::testing::_)).Times(0);
+    //     EXPECT_CALL(canvas, drawRect(::testing::_, ::testing::_)).Times(0);
+    //     testExpoLinearGradientDrawableLayer.onDraw(canvas);
+    // }
+    
+    // SECTION("Test ExpoLinearGradientDrawableLayer::onDraw - Rect not set") {
+    //     ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+    //     volta::graphics::Canvas canvas{};
+    //     testExpoLinearGradientDrawableLayer.setRect(rect);
+    //     EXPECT_CALL(canvas, drawPath(::testing::_, ::testing::_)).Times(0);
+    //     EXPECT_CALL(canvas, drawRect(::testing::_, ::testing::_)).Times(1);
+    //     testExpoLinearGradientDrawableLayer.onDraw(canvas);
+    // }
+
+    // SECTION("Test ExpoLinearGradientDrawableLayer::onDraw - Path not set") {
+    //     ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+    //     volta::graphics::Canvas canvas{};
+    //     testExpoLinearGradientDrawableLayer.setPath(path);
+    //     EXPECT_CALL(canvas, drawPath(::testing::_, ::testing::_)).Times(1);
+    //     EXPECT_CALL(canvas, drawRect(::testing::_, ::testing::_)).Times(0);
+    //     testExpoLinearGradientDrawableLayer.onDraw(canvas);
+    // }
+
+    SECTION("Test ExpoLinearGradientDrawableLayer::calculateGradient - Colors are empty") {
+        ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+        testExpoLinearGradientDrawableLayer.calculateGradient();
+        REQUIRE(testExpoLinearGradientDrawableLayer.linearGradientShader_ == nullptr);
+    }
+
+    SECTION("Test ExpoLinearGradientDrawableLayer::calculateGradient - MismatchedLocationsWithColors") {
+        ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+        std::vector<uint32_t> colors_more{0xFF0000, 0x00FF00, 0x0000FF, 0x000000}; 
+        testExpoLinearGradientDrawableLayer.setColors(colors_more);
+        testExpoLinearGradientDrawableLayer.setLocations(locations);
+        testExpoLinearGradientDrawableLayer.calculateGradient();
+        REQUIRE(testExpoLinearGradientDrawableLayer.linearGradientShader_ == nullptr);
+    }
+
+    SECTION("Test ExpoLinearGradientDrawableLayer::calculateGradient - Locations are empty") {
+        ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+        REQUIRE(testExpoLinearGradientDrawableLayer.linearGradientShader_ == nullptr);
+        testExpoLinearGradientDrawableLayer.setColors(colors);
+        testExpoLinearGradientDrawableLayer.setStart(point1);
+        testExpoLinearGradientDrawableLayer.setStart(point2);
+        testExpoLinearGradientDrawableLayer.calculateGradient();
+        REQUIRE(testExpoLinearGradientDrawableLayer.linearGradientShader_ != nullptr);
+    }
+    
+    SECTION("Test ExpoLinearGradientDrawableLayer::calculateGradient - Locations are not empty") {
+        ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+        REQUIRE(testExpoLinearGradientDrawableLayer.linearGradientShader_ == nullptr);
+        testExpoLinearGradientDrawableLayer.setColors(colors);
+        testExpoLinearGradientDrawableLayer.setStart(point1);
+        testExpoLinearGradientDrawableLayer.setStart(point2);
+        testExpoLinearGradientDrawableLayer.setLocations(locations);
+        testExpoLinearGradientDrawableLayer.calculateGradient();
+        REQUIRE(testExpoLinearGradientDrawableLayer.linearGradientShader_ != nullptr);
+    }
+    
+    SECTION("Test ExpoLinearGradientDrawableLayer::setColors") {
+        ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+        testExpoLinearGradientDrawableLayer.setColors(colors);
+        REQUIRE(testExpoLinearGradientDrawableLayer.colors_ == colors);
+    }
+
+    SECTION("Test ExpoLinearGradientDrawableLayer::setStart") {
+        ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+        testExpoLinearGradientDrawableLayer.setStart(point1);
+        REQUIRE(testExpoLinearGradientDrawableLayer.start_ == point1);
+    }
+
+    SECTION("Test ExpoLinearGradientDrawableLayer::setEnd") {
+        ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+        testExpoLinearGradientDrawableLayer.setEnd(point1);
+        REQUIRE(testExpoLinearGradientDrawableLayer.end_ == point1);
+    }
+
+    SECTION("Test ExpoLinearGradientDrawableLayer::setLocations") {
+        ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+        testExpoLinearGradientDrawableLayer.setLocations(locations);
+        REQUIRE(testExpoLinearGradientDrawableLayer.locations_ == locations);
+    }
+
+    SECTION("Test ExpoLinearGradientDrawableLayer::setRect") {
+        ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+        testExpoLinearGradientDrawableLayer.setRect(rect);
+        REQUIRE(testExpoLinearGradientDrawableLayer.rect_ == rect);
+    }
+
+    SECTION("Test ExpoLinearGradientDrawableLayer::setPath") {
+        ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+        path.addRect(rect);
+        testExpoLinearGradientDrawableLayer.setPath(path);
+        REQUIRE(!testExpoLinearGradientDrawableLayer.path_.isEmpty());
+    }
+
+    SECTION("Test ExpoLinearGradientDrawableLayer::setSize") {
+        ExpoLinearGradientDrawableLayer testExpoLinearGradientDrawableLayer{};
+        float w=10.0f, h=20.0f;
+        testExpoLinearGradientDrawableLayer.setSize(w, h);
+        REQUIRE(testExpoLinearGradientDrawableLayer.size_ == volta::graphics::Point{w, h});
+    }
+}

package/kepler/test/ExpoLinearGradientView.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include "../ExpoLinearGradientView.h"
+
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "catch.hpp"
+
+using namespace volta::react;
+
+template<typename T>
+utils::json::JsonContainer initializeJsonArray(std::vector<T>& list) {
+    auto arr = utils::json::JsonContainer::createJsonArray();
+    for (auto element : list) {
+        arr.insert(element);
+    }
+    return arr;
+}
+
+TEST_CASE("ExpoLinearGradientView") {
+    SECTION("Test ExpoLinearGradientView::setColors") {
+        ExpoLinearGradientView testExpoLinearGradientView{};
+        std::vector<uint32_t> colors{0xFF0000, 0x00FF00, 0x0000FF};
+        auto arr = initializeJsonArray(colors);
+        testExpoLinearGradientView.setColors(arr);
+        REQUIRE(testExpoLinearGradientView.linearGradientDrawableLayer_.colors_ == colors);
+    }
+
+    SECTION("Test ExpoLinearGradientView::setStart") {
+        ExpoLinearGradientView testExpoLinearGradientView{};
+        std::vector<float> coords{1, 2};
+        auto arr = initializeJsonArray(coords);
+        testExpoLinearGradientView.setStart(arr);
+        REQUIRE(testExpoLinearGradientView.linearGradientDrawableLayer_.start_ == volta::graphics::Point{1, 2});
+    }
+
+    SECTION("Test ExpoLinearGradientView::setEnd") {
+        ExpoLinearGradientView testExpoLinearGradientView{};
+        std::vector<float> coords{1, 2};
+        auto arr = initializeJsonArray(coords);
+        testExpoLinearGradientView.setEnd(arr);
+        REQUIRE(testExpoLinearGradientView.linearGradientDrawableLayer_.end_ == volta::graphics::Point{1, 2});
+    }
+
+    SECTION("Test ExpoLinearGradientView::setLocations") {
+        ExpoLinearGradientView testExpoLinearGradientView{};
+        std::vector<float> locations{10, 20, 30};
+        auto arr = initializeJsonArray(locations);
+        testExpoLinearGradientView.setLocations(arr);
+        REQUIRE(testExpoLinearGradientView.linearGradientDrawableLayer_.locations_ == locations);
+    }
+
+    SECTION("Test ExpoLinearGradientView::updateLayoutMetrics") {
+        ExpoLinearGradientView testExpoLinearGradientView{};
+        auto oldLayoutMetrics = std::make_shared<KeplerViewComponentLayoutMetrics>();
+        auto newLayoutMetrics = std::make_shared<KeplerViewComponentLayoutMetrics>();
+        testExpoLinearGradientView.updateLayoutMetrics(oldLayoutMetrics, newLayoutMetrics);
+        REQUIRE(testExpoLinearGradientView.linearGradientDrawableLayer_.path_.isEmpty());
+    }
+
+    SECTION("Test ExpoLinearGradientView::updateLayoutMetrics ") {
+        ExpoLinearGradientView testExpoLinearGradientView{};
+        auto oldSize = testExpoLinearGradientView.linearGradientDrawableLayer_.size_;
+        auto oldProps = std::make_shared<KeplerViewComponentProps>();
+        auto newProps = std::make_shared<KeplerViewComponentProps>();
+        auto oldLayoutMetrics = std::make_shared<KeplerViewComponentLayoutMetrics>();
+        auto newLayoutMetrics = std::make_shared<KeplerViewComponentLayoutMetrics>();
+        volta::react::Rect oldFrame = {.size = {100, 200}};
+        volta::react::Rect newFrame = {.size = {300, 400}};
+        oldLayoutMetrics->frame = oldFrame;
+        newLayoutMetrics->frame = newFrame;
+
+        testExpoLinearGradientView.updateProps(oldProps, newProps);
+        testExpoLinearGradientView.updateLayoutMetrics(oldLayoutMetrics, newLayoutMetrics);
+
+        REQUIRE(testExpoLinearGradientView.linearGradientDrawableLayer_.size_ != oldSize);
+    }
+}

package/kepler/test/ExpoLinearGradientViewManager.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+
+#include <gmock/gmock-actions.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "catch.hpp"
+
+#include "../ExpoLinearGradientView.h"
+#include "../ExpoLinearGradientViewManager.h"
+
+using namespace volta::react;
+
+TEST_CASE("ExpoLinearGradientViewManager") {
+    SECTION("Test ExpoLinearGradientViewManager::reateComponentView") {
+        ExpoLinearGradientViewManager testExpoLinearGradientViewManager{};
+        auto component = testExpoLinearGradientViewManager.createComponentView();
+        auto ExpoLinearGradientViewComponent = std::dynamic_pointer_cast<ExpoLinearGradientView>(component);
+        REQUIRE(ExpoLinearGradientViewComponent != nullptr);
+    }
+
+    SECTION("Test ExpoLinearGradientViewManager::aggregatePropSetter") {
+        ExpoLinearGradientViewManager testExpoLinearGradientViewManager{};
+        PropSetterAggregator testAggregator{};
+        testExpoLinearGradientViewManager.aggregatePropSetters(testAggregator);
+        std::vector<std::string> propNames = {"colors", "startPoint", "endPoint", "locations"};
+        for (auto& propName : propNames) {
+            REQUIRE(testAggregator.propSetterMap_.find(propName) != testAggregator.propSetterMap_.end());
+        }
+    }
+}

package/package.json

@@ -0,0 +1 @@
+{"name": "@amazon-devices/expo-linear-gradient", "version": "2.0.1758683737+12.6.0", "description": "Provides a React component that renders a gradient view.", "main": "build/LinearGradient.js", "types": "build/LinearGradient.d.ts", "sideEffects": false, "scripts": {"build": "expo-module build", "clean": "expo-module clean", "lint": "expo-module lint", "test": "expo-module test", "expo-module": "expo-module"}, "kepler": {"temporary-alias-for-package": {"name": "expo-linear-gradient", "version": "12.6.0"}}, "keywords": ["react-native", "expo", "gradient"], "jest": {"preset": "expo-module-scripts"}, "repository": {"type": "git", "url": "https://github.com/expo/expo.git", "directory": "packages/expo-linear-gradient"}, "bugs": {"url": "https://github.com/expo/expo/issues"}, "author": "650 Industries, Inc.", "license": "See license in LICENSE", "homepage": "https://docs.expo.dev/versions/latest/sdk/linear-gradient/", "devDependencies": {"@testing-library/jest-dom": "^5.16.5", "@testing-library/react": "^13.4.0", "@testing-library/react-native": "^11.3.0", "expo-module-scripts": "^3.0.0"}, "peerDependencies": {"expo": "*"}}

package/react-native.config.js

@@ -0,0 +1,21 @@
+module.exports = {
+  dependencies: {
+    '@amazon-devices/react-native-kepler': {
+      platforms: {
+        kepler: null, // do not use platform definition from @react-native-kepler
+      },
+    },
+  },
+  dependency: {
+    platforms: {
+      kepler: {
+        autolink: {
+          ExpoLinearGradientLib: {
+            provider: 'system',
+            components: ['ExpoLinearGradient'],
+          },
+        },
+      },
+    },
+  },
+};