react-native-unistyles 3.0.0-alpha.8 → 3.0.0-beta.1

package/cxx/core/UnistylesRegistry.cpp

@@ -1,14 +1,15 @@
 #include "UnistylesRegistry.h"
 #include "UnistylesState.h"
+#include "Parser.h"
 
 using namespace margelo::nitro::unistyles;
 using namespace facebook;
 using namespace facebook::react;
 
-void core::UnistylesRegistry::registerTheme(jsi::Runtime& rt, std::string name, jsi::Object&& theme) {
+void core::UnistylesRegistry::registerTheme(jsi::Runtime& rt, std::string name, jsi::Value& theme) {
     auto& state = this->getState(rt);
 
-    state._jsThemes.emplace(name, jsi::WeakObject(rt, std::move(theme)));
+    state._jsThemes.emplace(name, std::move(theme));
     state._registeredThemeNames.push_back(name);
 }
 
@@ -60,37 +61,53 @@ void core::UnistylesRegistry::updateTheme(jsi::Runtime& rt, std::string& themeNa
 
     helpers::assertThat(rt, it != state._jsThemes.end(), "Unistyles: You're trying to update theme '" + themeName + "' but it wasn't registered.");
 
-    auto currentThemeValue = it->second.lock(rt);
-
-    helpers::assertThat(rt, currentThemeValue.isObject(), "Unistyles: Unable to update your theme from C++. It was already garbage collected.");
-
-    auto result = callback.call(rt, currentThemeValue.asObject(rt));
+    auto result = callback.call(rt, it->second);
 
     helpers::assertThat(rt, result.isObject(), "Unistyles: Returned theme is not an object. Please check your updateTheme function.");
 
-    it->second = jsi::WeakObject(rt, result.asObject(rt));
+    it->second = result.asObject(rt);
 }
 
 void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
+    jsi::Runtime& rt,
     const ShadowNodeFamily* shadowNodeFamily,
-    const core::Unistyle::Shared unistyle,
-    Variants& variants
+    std::vector<core::Unistyle::Shared>& unistyles,
+    Variants& variants,
+    std::vector<std::vector<folly::dynamic>>& arguments,
+    std::optional<std::string> uniquePressableId
 ) {
-    if (!this->_shadowRegistry.contains(shadowNodeFamily)) {
-        this->_shadowRegistry[shadowNodeFamily] = {};
+    auto parser = parser::Parser(nullptr);
+    shadow::ShadowLeafUpdates updates;
+    
+    for (size_t index = 0; index < unistyles.size(); index++) {
+        Unistyle::Shared unistyle = unistyles[index];
+
+        this->_shadowRegistry[&rt][shadowNodeFamily]
+            .emplace_back(std::make_shared<UnistyleData>(unistyle, variants, arguments[index], uniquePressableId));
+
+        // add or update node for shadow leaf updates
+        // dynamic functions are parsed later
+        if (unistyle->type == UnistyleType::Object) {
+            for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+                for (const auto& unistyleData : unistyles) {
+                    if (unistyleData->unistyle == unistyle && family == shadowNodeFamily) {
+                        updates[family] = parser.parseStylesToShadowTreeStyles(rt, {unistyleData});
+                    }
+                }
+            }
+        }
     }
 
-    this->_shadowRegistry[shadowNodeFamily].emplace_back(std::make_pair(unistyle, std::move(variants)));
+    this->trafficController.setUpdates(updates);
+    this->trafficController.resumeUnistylesTraffic();
 }
 
-void core::UnistylesRegistry::unlinkShadowNodeWithUnistyle(const ShadowNodeFamily* shadowNodeFamily, const core::Unistyle::Shared unistyle) {
-    auto& unistylesVec = this->_shadowRegistry[shadowNodeFamily];
-    auto it = std::find_if(unistylesVec.begin(), unistylesVec.end(), [unistyle](std::pair<core::Unistyle::Shared, Variants> pair){
-        return pair.first == unistyle;
-    });
+void core::UnistylesRegistry::unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, const ShadowNodeFamily* shadowNodeFamily) {
+    this->_shadowRegistry[&rt].erase(shadowNodeFamily);
+    this->trafficController.removeShadowNode(shadowNodeFamily);
 
-    if (it != unistylesVec.end()) {
-        this->_shadowRegistry[shadowNodeFamily].erase(it);
+    if (this->_shadowRegistry[&rt].empty()) {
+        this->_shadowRegistry.erase(&rt);
     }
 }
 
@@ -104,13 +121,11 @@ core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt
     DependencyMap dependencyMap;
     std::set<UnistyleDependency> uniqueDependencies(deps.begin(), deps.end());
 
-    for (const auto& [_, styleSheet] : this->_styleSheetRegistry[&rt]) {
-        for (const auto& [_, unistyle] : styleSheet->unistyles) {
-            // check if in the given stylesheet we have unistyle
-            // that depends on something affected
+    for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+        for (const auto& unistyleData : unistyles) {
             bool hasAnyOfDependencies = std::any_of(
-                unistyle->dependencies.begin(),
-                unistyle->dependencies.end(),
+                unistyleData->unistyle->dependencies.begin(),
+                unistyleData->unistyle->dependencies.end(),
                 [&uniqueDependencies](UnistyleDependency dep) {
                     return std::find(uniqueDependencies.begin(), uniqueDependencies.end(), dep) != uniqueDependencies.end();
                 }
@@ -120,42 +135,88 @@ core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt
                 continue;
             }
 
-            // if so, we need to find shadow family too
-            for (const auto& pair : this->_shadowRegistry) {
-                const auto& [family, unistyles] = pair;
+            // we need to take in count all unistyles from the shadowNode
+            // as user might be using spreads and not all of them may have dependencies
+            for (const auto& unistyleData : unistyles) {
+                dependencyMap[family].emplace_back(unistyleData);
+            }
 
-                for (const auto& [shadowUnistyle, variants] : unistyles) {
-                    if (unistyle != shadowUnistyle) {
-                        continue;
-                    }
+            break;
+        }
+    }
 
-                    dependencyMap[styleSheet][family].emplace_back(unistyle, variants);
+    return dependencyMap;
+}
+
+// called from proxied function only, we don't know host
+// so we need to rebuild all instances as they may have different variants
+void core::UnistylesRegistry::shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Value& maybePressableId) {
+    shadow::ShadowLeafUpdates updates;
+    auto parser = parser::Parser(nullptr);
+    std::optional<std::string> pressableId = maybePressableId.isString()
+        ? std::make_optional(maybePressableId.asString(rt).utf8(rt))
+        : std::nullopt;
+
+    for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+        for (const auto& unistyleData : unistyles) {
+            if (unistyleData->unistyle == unistyle) {
+                // special case for pressable
+                if (pressableId.has_value() && unistyleData->pressableId.has_value()) {
+                    if (pressableId.value() == unistyleData->pressableId.value()) {
+                        unistyleData->parsedStyle = jsi::Value(rt, unistyle->parsedStyle.value()).asObject(rt);
+                    }
                 }
+                
+                updates[family] = parser.parseStylesToShadowTreeStyles(rt, { unistyleData });
             }
         }
     }
 
-    return dependencyMap;
+    this->trafficController.setUpdates(updates);
 }
 
-core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt) {
-    DependencyMap dependencyMap;
+std::vector<std::shared_ptr<core::StyleSheet>> core::UnistylesRegistry::getStyleSheetsToRefresh(jsi::Runtime& rt, std::vector<UnistyleDependency>& unistylesDependencies) {
+    std::vector<std::shared_ptr<core::StyleSheet>> stylesheetsToRefresh{};
+    auto themeDidChangeIt = std::find(unistylesDependencies.begin(),
+                                      unistylesDependencies.end(),
+                                      UnistyleDependency::THEME);
+    auto themeDidChange = themeDidChangeIt != unistylesDependencies.end();
+    auto runtimeDidChange = (themeDidChange && unistylesDependencies.size() > 1) || unistylesDependencies.size() > 0;
+    
+    // if nothing changed, skip further lookup
+    if (!themeDidChange && !runtimeDidChange) {
+        return stylesheetsToRefresh;
+    }
 
-    for (const auto& [_, styleSheet] : this->_styleSheetRegistry[&rt]) {
-        for (const auto& [_, unistyle] : styleSheet->unistyles) {
-            for (const auto& pair : this->_shadowRegistry) {
-                const auto& [family, unistyles] = pair;
+    auto& styleSheets = this->_styleSheetRegistry[&rt];
 
-                for (const auto& [shadowUnistyle, variants] : unistyles) {
-                    if (unistyle != shadowUnistyle) {
-                        continue;
-                    }
+    std::for_each(styleSheets.begin(), styleSheets.end(), [&](std::pair<int, std::shared_ptr<core::StyleSheet>> pair){
+        auto& [_, styleSheet] = pair;
 
-                    dependencyMap[styleSheet][family].emplace_back(unistyle, variants);
+        if (styleSheet->type == StyleSheetType::ThemableWithMiniRuntime) {
+            for (const auto& unistylePair: styleSheet->unistyles) {
+                auto& [_, unistyle] = unistylePair;
+                
+                bool hasAnyOfDependencies = std::any_of(
+                    unistyle->dependencies.begin(),
+                    unistyle->dependencies.end(),
+                    [&unistylesDependencies](UnistyleDependency dep) {
+                        return std::find(unistylesDependencies.begin(), unistylesDependencies.end(), dep) != unistylesDependencies.end();
+                    }
+                );
+                
+                if (hasAnyOfDependencies) {
+                    stylesheetsToRefresh.emplace_back(styleSheet);
+                    
+                    return;
                 }
             }
         }
-    }
 
-    return dependencyMap;
+        if (styleSheet->type == StyleSheetType::Themable && themeDidChange) {
+            stylesheetsToRefresh.emplace_back(styleSheet);
+        }
+    });
+
+    return stylesheetsToRefresh;
 }

package/cxx/core/UnistylesRegistry.h

@@ -2,6 +2,7 @@
 
 #include "set"
 #include <jsi/jsi.h>
+#include <folly/dynamic.h>
 #include <react/renderer/uimanager/UIManager.h>
 #include <unordered_map>
 #include <unordered_set>
@@ -10,6 +11,7 @@
 #include "StyleSheet.h"
 #include "Unistyle.h"
 #include "UnistyleData.h"
+#include "ShadowTrafficController.h"
 
 namespace margelo::nitro::unistyles::core {
 
@@ -18,10 +20,7 @@ struct UnistylesState;
 using namespace facebook;
 using namespace facebook::react;
 
-using DependencyMap = std::unordered_map<
-    std::shared_ptr<core::StyleSheet>,
-    std::unordered_map<const ShadowNodeFamily*, std::vector<UnistyleData>>
->;
+using DependencyMap = std::unordered_map<const ShadowNodeFamily*, std::vector<std::shared_ptr<UnistyleData>>>;
 
 struct UnistylesRegistry: public StyleSheetRegistry {
     static UnistylesRegistry& get();
@@ -29,7 +28,7 @@ struct UnistylesRegistry: public StyleSheetRegistry {
     UnistylesRegistry(const UnistylesRegistry&) = delete;
     UnistylesRegistry(const UnistylesRegistry&&) = delete;
 
-    void registerTheme(jsi::Runtime& rt, std::string name, jsi::Object&& theme);
+    void registerTheme(jsi::Runtime& rt, std::string name, jsi::Value& theme);
     void registerBreakpoints(jsi::Runtime& rt, std::vector<std::pair<std::string, double>>& sortedBreakpoints);
     void setPrefersAdaptiveThemes(jsi::Runtime& rt, bool prefersAdaptiveThemes);
     void setInitialThemeName(jsi::Runtime& rt, std::string themeName);
@@ -37,21 +36,23 @@ struct UnistylesRegistry: public StyleSheetRegistry {
 
     UnistylesState& getState(jsi::Runtime& rt);
     void createState(jsi::Runtime& rt);
-    void linkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared, Variants& variants);
-    void unlinkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared);
+    std::vector<std::shared_ptr<core::StyleSheet>> getStyleSheetsToRefresh(jsi::Runtime& rt, std::vector<UnistyleDependency>& unistylesDependencies);
+    void linkShadowNodeWithUnistyle(jsi::Runtime& rt, const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>& unistyles, Variants& variants, std::vector<std::vector<folly::dynamic>>&, std::optional<std::string> uniquePressableId);
+    void unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, const ShadowNodeFamily*);
     std::shared_ptr<core::StyleSheet> addStyleSheet(jsi::Runtime& rt, int tag, core::StyleSheetType type, jsi::Object&& rawValue);
     DependencyMap buildDependencyMap(jsi::Runtime& rt, std::vector<UnistyleDependency>& deps);
-    DependencyMap buildDependencyMap(jsi::Runtime& rt);
+    void shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Value& maybePressableId);
+    shadow::ShadowTrafficController trafficController{};
 
 private:
     UnistylesRegistry() = default;
 
     std::unordered_map<jsi::Runtime*, UnistylesState> _states{};
     std::unordered_map<jsi::Runtime*, std::unordered_map<int, std::shared_ptr<core::StyleSheet>>> _styleSheetRegistry{};
-    std::unordered_map<const ShadowNodeFamily*, std::vector<std::pair<core::Unistyle::Shared, Variants>>> _shadowRegistry{};
+    std::unordered_map<jsi::Runtime*, std::unordered_map<const ShadowNodeFamily*, std::vector<const std::shared_ptr<UnistyleData>>>> _shadowRegistry{};
 };
 
-UnistylesRegistry& UnistylesRegistry::get() {
+inline UnistylesRegistry& UnistylesRegistry::get() {
     static UnistylesRegistry cache;
 
     return cache;

package/cxx/core/UnistylesState.cpp

@@ -23,9 +23,13 @@ std::optional<std::string>& core::UnistylesState::getCurrentThemeName() {
     return this->_currentThemeName;
 }
 
-jsi::Object core::UnistylesState::getJSTheme() {
+jsi::Object core::UnistylesState::getCurrentJSTheme() {
     auto hasSomeThemes = _registeredThemeNames.size() > 0;
 
+    if (!hasSomeThemes && !this->hasUserConfig) {
+        helpers::assertThat(*_rt, false, "Unistyles: One of your stylesheets is trying to get the theme, but no theme has been selected yet. Did you forget to call StyleSheet.configure? If you called it, make sure you did so before any StyleSheet.create.");
+    }
+
     // return empty object, if user didn't register any themes
     if (!hasSomeThemes) {
         return jsi::Object(*_rt);
@@ -37,14 +41,22 @@ jsi::Object core::UnistylesState::getJSTheme() {
 
     helpers::assertThat(*_rt, it != this->_jsThemes.end(), "Unistyles: You're trying to get theme '" + _currentThemeName.value() + "', but it was not registered. Did you forget to register it with StyleSheet.configure?");
 
-    auto maybeTheme = it->second.lock(*_rt);
+    return it->second.asObject(*_rt);
+}
 
-    helpers::assertThat(*_rt, maybeTheme.isObject(), "Unistyles: Unable to retrieve your theme from C++ as it has already been garbage collected, likely due to multiple hot reloads. Please live reload the app.");
+jsi::Object core::UnistylesState::getJSThemeByName(std::string& themeName) {
+    auto it = this->_jsThemes.find(themeName);
 
-    return maybeTheme.asObject(*_rt);
+    helpers::assertThat(*_rt, it != this->_jsThemes.end(), "Unistyles: You're trying to get theme '" + themeName + "', but it was not registered. Did you forget to register it with StyleSheet.configure?");
+
+    return it->second.asObject(*_rt);
 }
 
 void core::UnistylesState::computeCurrentBreakpoint(int screenWidth) {
+    if (this->_sortedBreakpointPairs.size() == 0) {
+        return;
+    }
+
     this->_currentBreakpointName = helpers::getBreakpointFromScreenWidth(
         screenWidth,
         this->_sortedBreakpointPairs
@@ -87,9 +99,18 @@ int core::UnistylesState::parseColor(jsi::Value& maybeColor) {
     if (!maybeColor.isString()) {
         return 0;
     }
-    
-    // we must convert it to uint32_t first, otherwise color will be broken
-    uint32_t color = this->_processColorFn.get()->call(*_rt, maybeColor.asString(*_rt)).asNumber();
 
-    return color;
+    auto colorString = maybeColor.asString(*_rt);
+
+    if (!this->_colorCache.contains(colorString.utf8(*_rt).c_str())) {
+        #ifdef ANDROID
+            int color = this->_processColorFn.get()->call(*_rt, colorString).asNumber();
+        #else
+            uint32_t color = this->_processColorFn.get()->call(*_rt, colorString).asNumber();
+        #endif
+
+        this->_colorCache[colorString.utf8(*_rt).c_str()] = color ? color : 0;
+    }
+
+    return this->_colorCache[colorString.utf8(*_rt).c_str()];
 }

package/cxx/core/UnistylesState.h

@@ -17,6 +17,7 @@ struct UnistylesState {
     UnistylesState(const UnistylesState&) = delete;
     UnistylesState(const UnistylesState&&) = delete;
 
+    bool hasUserConfig = false;
     bool hasAdaptiveThemes();
     bool hasInitialTheme();
     bool getPrefersAdaptiveThemes();
@@ -28,14 +29,15 @@ struct UnistylesState {
     std::optional<std::string> getCurrentBreakpointName();
     std::vector<std::pair<std::string, double>> getSortedBreakpointPairs();
 
-    jsi::Object getJSTheme();
+    jsi::Object getCurrentJSTheme();
+    jsi::Object getJSThemeByName(std::string& themeName);
     int parseColor(jsi::Value& color);
     void computeCurrentBreakpoint(int screenWidth);
     void registerProcessColorFunction(jsi::Function&& fn);
 
 private:
     jsi::Runtime* _rt;
-    std::unordered_map<std::string, jsi::WeakObject> _jsThemes{};
+    std::unordered_map<std::string, jsi::Value> _jsThemes{};
     std::optional<bool> _prefersAdaptiveThemes = std::nullopt;
     std::optional<std::string> _initialThemeName = std::nullopt;
     std::optional<std::string> _currentBreakpointName = std::nullopt;
@@ -43,6 +45,7 @@ private:
     std::vector<std::string> _registeredThemeNames{};
     std::optional<std::string> _currentThemeName = std::nullopt;
     std::shared_ptr<jsi::Function> _processColorFn;
+    std::unordered_map<std::string, uint32_t> _colorCache{};
 
     friend class UnistylesRegistry;
 };

package/cxx/hybridObjects/HybridNavigationBar.cpp

@@ -1,9 +1,5 @@
 #include "HybridNavigationBar.h"
 
-void HybridNavigationBar::setBackgroundColor(double color) {
-    this->_nativePlatform.setNavigationBarBackgroundColor(color);
-};
-
 void HybridNavigationBar::setHidden(bool isHidden) {
     this->_nativePlatform.setNavigationBarHidden(isHidden);
 };

package/cxx/hybridObjects/HybridNavigationBar.h

@@ -1,19 +1,18 @@
 #pragma once
 
 #include "HybridUnistylesNavigationBarSpec.hpp"
-#include "Unistyles-Swift-Cxx-Umbrella.hpp"
+#include "NativePlatform.h"
 #include <optional>
 
 using namespace margelo::nitro::unistyles;
 
 struct HybridNavigationBar: public HybridUnistylesNavigationBarSpec {
     HybridNavigationBar(Unistyles::HybridNativePlatformSpecCxx nativePlatform): HybridObject(TAG), _nativePlatform{nativePlatform} {}
-    
-    void setBackgroundColor(double color) override;
+
     void setHidden(bool isHidden) override;
     double getWidth() override;
     double getHeight() override;
-    
+
 private:
     Unistyles::HybridNativePlatformSpecCxx _nativePlatform;
 };

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -4,28 +4,35 @@ using namespace margelo::nitro::unistyles;
 using namespace facebook::react;
 
 jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
-    helpers::assertThat(rt, count == 3, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected 3 arguments.");
-    
+    helpers::assertThat(rt, count == 5, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected 5 arguments.");
+
     ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
-    core::Unistyle::Shared unistyleWrapper = core::unistyleFromValue(rt, args[1]);
+    std::vector<core::Unistyle::Shared> unistyleWrappers = core::unistyleFromValue(rt, args[1]);
     core::Variants variants = helpers::variantsToPairs(rt, args[2].asObject(rt));
-    
+    jsi::Array rawArguments = args[3].asObject(rt).asArray(rt);
+    std::optional<std::string> uniquePressableId = args[4].isUndefined()
+            ? std::nullopt
+            : std::make_optional<std::string>(args[4].asString(rt).utf8(rt));
+    std::vector<std::vector<folly::dynamic>> arguments;
     auto& registry = core::UnistylesRegistry::get();
     
-    registry.linkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper, variants);
+    helpers::iterateJSIArray(rt, rawArguments, [&rt, &arguments](size_t index, jsi::Value& value){
+        arguments.push_back(helpers::parseDynamicFunctionArguments(rt, value.asObject(rt).asArray(rt)));
+    });
     
+    registry.linkShadowNodeWithUnistyle(rt, &shadowNodeWrapper->getFamily(), unistyleWrappers, variants, arguments, uniquePressableId);
+
     return jsi::Value::undefined();
 }
 
 jsi::Value HybridShadowRegistry::unlink(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
-    helpers::assertThat(rt, count == 2, "Unistyles: Invalid babel transform 'ShadowRegistry unlink' expected 2 arguments.");
-    
+    helpers::assertThat(rt, count == 1, "Unistyles: Invalid babel transform 'ShadowRegistry unlink' expected 1 arguments.");
+
     ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
-    core::Unistyle::Shared unistyleWrapper = core::unistyleFromValue(rt, args[1]);
-    
+
     auto& registry = core::UnistylesRegistry::get();
 
-    registry.unlinkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper);
-    
+    registry.unlinkShadowNodeWithUnistyles(rt, &shadowNodeWrapper->getFamily());
+
     return jsi::Value::undefined();
 }

package/cxx/hybridObjects/HybridStatusBar.cpp

@@ -1,9 +1,5 @@
 #include "HybridStatusBar.h"
 
-void HybridStatusBar::setBackgroundColor(double color) {
-    this->_nativePlatform.setStatusBarBackgroundColor(color);
-}
-
 double HybridStatusBar::getWidth() {
     return this->_nativePlatform.getStatusBarDimensions().width;
 }

package/cxx/hybridObjects/HybridStatusBar.h

@@ -1,19 +1,18 @@
 #pragma once
 
 #include "HybridUnistylesStatusBarSpec.hpp"
-#include "Unistyles-Swift-Cxx-Umbrella.hpp"
+#include "NativePlatform.h"
 #include <optional>
 
 using namespace margelo::nitro::unistyles;
 
 struct HybridStatusBar: public HybridUnistylesStatusBarSpec {
     HybridStatusBar(Unistyles::HybridNativePlatformSpecCxx nativePlatform): HybridObject(TAG), _nativePlatform{nativePlatform} {}
- 
-    void setBackgroundColor(double color) override;
+
     double getWidth() override;
     double getHeight() override;
     void setHidden(bool isHidden) override;
-    
+
 private:
     Unistyles::HybridNativePlatformSpecCxx _nativePlatform;
 };