react-native-unistyles 3.0.0-alpha.4 → 3.0.0-alpha.40

package/cxx/core/UnistylesCommitShadowNode.h

@@ -8,6 +8,7 @@ namespace margelo::nitro::unistyles::core {
 // React Native uses 0-10
 // Reanimated uses 27-28
 constexpr shadow::ShadowNodeTraits::Trait UnistylesCommitTrait{1 << 30};
+constexpr shadow::ShadowNodeTraits::Trait UnistylesMountTrait{1 << 31};
 
 struct UnistylesCommitShadowNode: public shadow::ShadowNode {
     inline void addUnistylesCommitTrait() {
@@ -21,6 +22,18 @@ struct UnistylesCommitShadowNode: public shadow::ShadowNode {
     inline bool hasUnistylesCommitTrait() {
         return traits_.check(UnistylesCommitTrait);
     }
+    
+    inline void addUnistylesMountTrait() {
+        traits_.set(UnistylesMountTrait);
+    }
+    
+    inline void removeUnistylesMountTrait() {
+        traits_.unset(UnistylesMountTrait);
+    }
+    
+    inline bool hasUnistylesMountTrait() {
+        return traits_.check(UnistylesMountTrait);
+    }
 };
 
 }

package/cxx/core/UnistylesMountHook.cpp

@@ -0,0 +1,28 @@
+#include "UnistylesMountHook.h"
+
+using namespace margelo::nitro::unistyles;
+using namespace facebook::react;
+
+core::UnistylesMountHook::~UnistylesMountHook() noexcept {
+    _uiManager->unregisterMountHook(*this);
+}
+
+void core::UnistylesMountHook::shadowTreeDidMount(RootShadowNode::Shared const &rootShadowNode, double mountTime) noexcept {
+    auto rootNode = std::const_pointer_cast<RootShadowNode>(rootShadowNode);
+    auto unistylesRootNode = std::reinterpret_pointer_cast<core::UnistylesCommitShadowNode>(rootNode);
+
+    // if this is Unistyles commit, do nothing
+    if (unistylesRootNode->hasUnistylesMountTrait()) {
+        unistylesRootNode->removeUnistylesMountTrait();
+
+        return;
+    }
+
+    // this is React Native or Reanimated commit
+    // one more time merge Unistyles changes
+    auto& registry = core::UnistylesRegistry::get();
+
+    if (!registry.trafficController.shouldStop()) {
+        shadow::ShadowTreeManager::updateShadowTree(this->_uiManager->getShadowTreeRegistry());
+    }
+}

package/cxx/core/UnistylesMountHook.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <react/renderer/uimanager/UIManager.h>
+#include <react/renderer/uimanager/UIManagerMountHook.h>
+#include "ShadowTreeManager.h"
+#include "HybridUnistylesRuntime.h"
+
+namespace margelo::nitro::unistyles::core {
+
+using namespace facebook::react;
+
+struct UnistylesMountHook : public UIManagerMountHook {
+    UnistylesMountHook(std::shared_ptr<UIManager> uiManager, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
+        : _uiManager{uiManager}, _unistylesRuntime{unistylesRuntime} {
+        _uiManager->registerMountHook(*this);
+    }
+
+    ~UnistylesMountHook() noexcept override;
+
+    void shadowTreeDidMount(RootShadowNode::Shared const &rootShadowNode, double mountTime) noexcept override;
+
+private:
+    std::shared_ptr<UIManager> _uiManager;
+    std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+};
+
+}

package/cxx/core/UnistylesRegistry.cpp

@@ -1,19 +1,15 @@
 #include "UnistylesRegistry.h"
 #include "UnistylesState.h"
+#include "Parser.h"
 
 using namespace margelo::nitro::unistyles;
 using namespace facebook;
 using namespace facebook::react;
 
-using DependencyMap = std::unordered_map<
-    std::shared_ptr<core::StyleSheet>,
-    std::unordered_map<const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>>
->;
-
-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);
 }
 
@@ -62,115 +58,155 @@ void core::UnistylesRegistry::createState(jsi::Runtime& rt) {
 void core::UnistylesRegistry::updateTheme(jsi::Runtime& rt, std::string& themeName, jsi::Function&& callback) {
     auto& state = this->getState(rt);
     auto it = state._jsThemes.find(themeName);
-    
+
     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));
-    
-    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));
-}
+    auto result = callback.call(rt, it->second);
 
-void core::UnistylesRegistry::linkShadowNodeWithUnistyle(const ShadowNodeFamily* shadowNodeFamily, const core::Unistyle::Shared unistyle) {
-    if (!this->_shadowRegistry.contains(shadowNodeFamily)) {
-        this->_shadowRegistry[shadowNodeFamily] = {};
-    }
-    
-    this->_shadowRegistry[shadowNodeFamily].emplace_back(unistyle);
+    helpers::assertThat(rt, result.isObject(), "Unistyles: Returned theme is not an object. Please check your updateTheme function.");
+
+    it->second = result.asObject(rt);
 }
 
-void core::UnistylesRegistry::unlinkShadowNodeWithUnistyle(const ShadowNodeFamily* shadowNodeFamily, const core::Unistyle::Shared unistyle) {
-    auto& unistylesVec = this->_shadowRegistry[shadowNodeFamily];
-    auto it = std::find(unistylesVec.begin(), unistylesVec.end(), unistyle);
+void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
+    jsi::Runtime& rt,
+    const ShadowNodeFamily* shadowNodeFamily,
+    std::vector<core::Unistyle::Shared>& unistyles,
+    Variants& variants,
+    std::vector<std::vector<folly::dynamic>>& arguments
+) {
+    auto parser = parser::Parser(nullptr);
+    shadow::ShadowLeafUpdates updates;
     
-    if (it != unistylesVec.end()) {
-        this->_shadowRegistry[shadowNodeFamily].erase(it);
+    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]));
+
+        // 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->trafficController.setUpdates(updates);
+    this->trafficController.resumeUnistylesTraffic();
 }
 
-std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::addStyleSheet(int tag, core::StyleSheetType type, jsi::Object&& rawValue) {
-    this->_styleSheetRegistry.emplace_back(std::make_shared<core::StyleSheet>(tag, type, std::move(rawValue)));
+void core::UnistylesRegistry::unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, const ShadowNodeFamily* shadowNodeFamily) {
+    this->_shadowRegistry[&rt].erase(shadowNodeFamily);
+    this->trafficController.removeShadowNode(shadowNodeFamily);
 
-    return this->_styleSheetRegistry.back();
+    if (this->_shadowRegistry[&rt].empty()) {
+        this->_shadowRegistry.erase(&rt);
+    }
 }
 
-void core::UnistylesRegistry::removeStyleSheet(int tag) {
-    auto it = std::find_if(
-        this->_styleSheetRegistry.begin(),
-        this->_styleSheetRegistry.end(),
-        [tag](std::shared_ptr<StyleSheet> styleSheet){
-            return styleSheet->tag == tag;
-        }
-    );
-    
-    if (it == this->_styleSheetRegistry.cend()) {
-        throw std::runtime_error("stylesheet with tag: " + std::to_string(tag) + " cannot be found.");
-    }
+std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::addStyleSheet(jsi::Runtime& rt, int unid, core::StyleSheetType type, jsi::Object&& rawValue) {
+    this->_styleSheetRegistry[&rt][unid] = std::make_shared<core::StyleSheet>(unid, type, std::move(rawValue));
 
-    this->_styleSheetRegistry.erase(it);
+    return this->_styleSheetRegistry[&rt][unid];
 }
-    
-DependencyMap core::UnistylesRegistry::buildDependencyMap(std::vector<UnistyleDependency>& deps) {
+
+core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt, std::vector<UnistyleDependency>& deps) {
     DependencyMap dependencyMap;
- 
-    for (const auto& styleSheet : this->_styleSheetRegistry) {
-        for (const auto& [_, unistyle] : styleSheet->unistyles) {
-            // check if in the given stylesheet we have unistyle
-            // that depends on something affected
+    std::set<UnistyleDependency> uniqueDependencies(deps.begin(), deps.end());
+
+    for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+        for (const auto& unistyleData : unistyles) {
             bool hasAnyOfDependencies = std::any_of(
-                unistyle->dependencies.begin(),
-                unistyle->dependencies.end(),
-                [&deps](UnistyleDependency dep) {
-                    return std::find(deps.begin(), deps.end(), dep) != deps.end();
+                unistyleData->unistyle->dependencies.begin(),
+                unistyleData->unistyle->dependencies.end(),
+                [&uniqueDependencies](UnistyleDependency dep) {
+                    return std::find(uniqueDependencies.begin(), uniqueDependencies.end(), dep) != uniqueDependencies.end();
                 }
             );
-            
+
             if (!hasAnyOfDependencies) {
                 continue;
             }
-            
-            // if so, we need to find shadow family too
-            for (const auto& pair : this->_shadowRegistry) {
-                const auto& [family, unistyles] = pair;
-                
-                for (const auto& shadowUnistyle : unistyles) {
-                    if (unistyle != shadowUnistyle) {
-                        continue;
-                    }
 
-                    dependencyMap[styleSheet][family].push_back(shadowUnistyle);
-                }
+            // 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);
             }
+
+            break;
         }
     }
 
     return dependencyMap;
 }
 
-DependencyMap core::UnistylesRegistry::buildDependencyMap() {
-    DependencyMap dependencyMap;
- 
-    for (const auto& styleSheet : this->_styleSheetRegistry) {
-        for (const auto& [_, unistyle] : styleSheet->unistyles) {
-            for (const auto& pair : this->_shadowRegistry) {
-                const auto& [family, unistyles] = pair;
+// 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) {
+    shadow::ShadowLeafUpdates updates;
+    auto parser = parser::Parser(nullptr);
+
+    for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+        for (const auto& unistyleData : unistyles) {
+            if (unistyleData->unistyle == unistyle) {
+                // update state eg. for pressable
+                unistyleData->parsedStyle = jsi::Value(rt, unistyle->parsedStyle.value()).asObject(rt);
+                updates[family] = parser.parseStylesToShadowTreeStyles(rt, { unistyleData });
+            }
+        }
+    }
+
+    this->trafficController.setUpdates(updates);
+}
+
+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;
+    }
+
+    auto& styleSheets = this->_styleSheetRegistry[&rt];
+
+    std::for_each(styleSheets.begin(), styleSheets.end(), [&](std::pair<int, std::shared_ptr<core::StyleSheet>> pair){
+        auto& [_, styleSheet] = pair;
+
+        if (styleSheet->type == StyleSheetType::ThemableWithMiniRuntime) {
+            for (const auto& unistylePair: styleSheet->unistyles) {
+                auto& [_, unistyle] = unistylePair;
                 
-                for (const auto& shadowUnistyle : unistyles) {
-                    if (unistyle != shadowUnistyle) {
-                        continue;
+                bool hasAnyOfDependencies = std::any_of(
+                    unistyle->dependencies.begin(),
+                    unistyle->dependencies.end(),
+                    [&unistylesDependencies](UnistyleDependency dep) {
+                        return std::find(unistylesDependencies.begin(), unistylesDependencies.end(), dep) != unistylesDependencies.end();
                     }
-
-                    // make sure to use base Unistyle class
-                    dependencyMap[styleSheet][family].push_back(shadowUnistyle);
+                );
+                
+                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

@@ -1,6 +1,8 @@
 #pragma once
 
+#include "set"
 #include <jsi/jsi.h>
+#include <folly/dynamic.h>
 #include <react/renderer/uimanager/UIManager.h>
 #include <unordered_map>
 #include <unordered_set>
@@ -8,6 +10,8 @@
 #include "StyleSheetRegistry.h"
 #include "StyleSheet.h"
 #include "Unistyle.h"
+#include "UnistyleData.h"
+#include "ShadowTrafficController.h"
 
 namespace margelo::nitro::unistyles::core {
 
@@ -16,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<core::Unistyle::Shared>>
->;
+using DependencyMap = std::unordered_map<const ShadowNodeFamily*, std::vector<std::shared_ptr<UnistyleData>>>;
 
 struct UnistylesRegistry: public StyleSheetRegistry {
     static UnistylesRegistry& get();
@@ -27,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);
@@ -35,22 +36,23 @@ struct UnistylesRegistry: public StyleSheetRegistry {
 
     UnistylesState& getState(jsi::Runtime& rt);
     void createState(jsi::Runtime& rt);
-    void linkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared);
-    void unlinkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared);
-    std::shared_ptr<core::StyleSheet> addStyleSheet(int tag, core::StyleSheetType type, jsi::Object&& rawValue);
-    void removeStyleSheet(int tag);
-    DependencyMap buildDependencyMap(std::vector<UnistyleDependency>& deps);
-    DependencyMap buildDependencyMap();
+    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>>&);
+    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);
+    void shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle);
+    shadow::ShadowTrafficController trafficController{};
 
 private:
     UnistylesRegistry() = default;
 
     std::unordered_map<jsi::Runtime*, UnistylesState> _states{};
-    std::vector<std::shared_ptr<core::StyleSheet>> _styleSheetRegistry{};
-    std::unordered_map<const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>> _shadowRegistry{};
+    std::unordered_map<jsi::Runtime*, std::unordered_map<int, std::shared_ptr<core::StyleSheet>>> _styleSheetRegistry{};
+    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,27 +4,32 @@ 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 == 2, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected two arguments.");
-    
+    helpers::assertThat(rt, count == 4, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected 4 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::vector<std::vector<folly::dynamic>> arguments;
     auto& registry = core::UnistylesRegistry::get();
     
-    registry.linkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper);
+    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);
+
     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 two 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;
 };