react-native-unistyles 3.0.0-alpha.3 → 3.0.0-alpha.30

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,26 @@
+#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;
+    }
+
+    // React Native commit did mount
+    auto& registry = core::UnistylesRegistry::get();
+
+    // so, resume Unistyles commits
+    registry.trafficController.resumeUnistylesTraffic();
+}

package/cxx/core/UnistylesMountHook.h

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

package/cxx/core/UnistylesRegistry.cpp

@@ -5,15 +5,10 @@ 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 +57,117 @@ 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(), "you're trying to update theme '" + themeName + "' but it wasn't registered.");
-    
-    auto currentThemeValue = it->second.lock(rt);
-    
-    helpers::assertThat(rt, currentThemeValue.isObject(), "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(), "returned theme is not an object. Please check your updateTheme function.");
-
-    it->second = jsi::WeakObject(rt, result.asObject(rt));
+
+    helpers::assertThat(rt, it != state._jsThemes.end(), "Unistyles: You're trying to update theme '" + themeName + "' but it wasn't registered.");
+
+    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 = result.asObject(rt);
 }
 
-void core::UnistylesRegistry::linkShadowNodeWithUnistyle(const ShadowNodeFamily* shadowNodeFamily, const core::Unistyle::Shared unistyle) {
-    if (!this->_shadowRegistry.contains(shadowNodeFamily)) {
-        this->_shadowRegistry[shadowNodeFamily] = {};
+void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
+    jsi::Runtime& rt,
+    const ShadowNodeFamily* shadowNodeFamily,
+    std::vector<core::Unistyle::Shared>& unistyles,
+    Variants& variants,
+    std::vector<folly::dynamic>& arguments
+) {
+    if (!this->_shadowRegistry[&rt].contains(shadowNodeFamily)) {
+        this->_shadowRegistry[&rt][shadowNodeFamily] = {};
     }
-    
-    this->_shadowRegistry[shadowNodeFamily].emplace_back(unistyle);
+
+    std::for_each(unistyles.begin(), unistyles.end(), [&, this](Unistyle::Shared unistyle){
+        this->_shadowRegistry[&rt][shadowNodeFamily].emplace_back(std::make_shared<UnistyleData>(unistyle, variants, arguments));
+    });
 }
 
-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);
-    
-    if (it != unistylesVec.end()) {
-        this->_shadowRegistry[shadowNodeFamily].erase(it);
-    }
+void core::UnistylesRegistry::unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, const ShadowNodeFamily* shadowNodeFamily) {
+    this->_shadowRegistry[&rt].erase(shadowNodeFamily);
 }
 
-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)));
+core::Unistyle::Shared core::UnistylesRegistry::findUnistyleFromKey(jsi::Runtime& rt, std::string styleKey, int tag) {
+    auto targetStyleSheet = this->_styleSheetRegistry[&rt][tag];
+
+    if (targetStyleSheet == nullptr) {
+        return nullptr;
+    }
 
-    return this->_styleSheetRegistry.back();
+    return targetStyleSheet.get()->unistyles[styleKey];
 }
 
-std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::getStyleSheetById(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.");
-    }
-    
-    return *it;
+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));
+
+    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() {
+core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt) {
     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;
-                
-                for (const auto& shadowUnistyle : unistyles) {
-                    if (unistyle != shadowUnistyle) {
-                        continue;
-                    }
-
-                    // make sure to use base Unistyle class
-                    dependencyMap[styleSheet][family].push_back(shadowUnistyle);
-                }
-            }
+
+    for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+        for (const auto& unistyleData : unistyles) {
+            dependencyMap[family].emplace_back(unistyleData);
         }
     }
 
     return dependencyMap;
 }
+
+std::vector<std::shared_ptr<core::StyleSheet>> core::UnistylesRegistry::getStyleSheetsToRefresh(jsi::Runtime& rt, bool themeDidChange, bool runtimeDidChange) {
+    std::vector<std::shared_ptr<core::StyleSheet>> stylesheetsToRefresh{};
+
+    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 && (themeDidChange || runtimeDidChange)) {
+            stylesheetsToRefresh.emplace_back(styleSheet);
+
+            return;
+        }
+
+        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,19 +36,21 @@ 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);
-    std::shared_ptr<core::StyleSheet> getStyleSheetById(int tag);
-    DependencyMap buildDependencyMap(std::vector<UnistyleDependency>& deps);
-    DependencyMap buildDependencyMap();
+    std::vector<std::shared_ptr<core::StyleSheet>> getStyleSheetsToRefresh(jsi::Runtime& rt, bool themeDidChange, bool runtimeDidChange);
+    void linkShadowNodeWithUnistyle(jsi::Runtime& rt, const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>& unistyles, Variants& variants, 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);
+    Unistyle::Shared findUnistyleFromKey(jsi::Runtime& rt, std::string styleKey, int tag);
+    DependencyMap buildDependencyMap(jsi::Runtime& rt);
+    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<std::shared_ptr<UnistyleData>>>> _shadowRegistry{};
 };
 
 UnistylesRegistry& UnistylesRegistry::get() {

package/cxx/core/UnistylesState.cpp

@@ -12,7 +12,7 @@ bool core::UnistylesState::hasAdaptiveThemes() {
 }
 
 void core::UnistylesState::setTheme(std::string themeName) {
-    helpers::assertThat(*_rt, helpers::vecContainsKeys(this->_registeredThemeNames, {themeName}), "You're trying to set theme to: '" + std::string(themeName) + "', but it wasn't registered.");
+    helpers::assertThat(*_rt, helpers::vecContainsKeys(this->_registeredThemeNames, {themeName}), "Unistyles: You're trying to set theme to: '" + std::string(themeName) + "', but it wasn't registered.");
 
     if (themeName != this->_currentThemeName) {
         this->_currentThemeName = themeName;
@@ -23,28 +23,40 @@ 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);
     }
 
-    helpers::assertThat(*_rt, _currentThemeName.has_value(), "one of your stylesheets is trying to get the theme, but no theme has been selected yet. Did you forget to select an initial theme?");
+    helpers::assertThat(*_rt, _currentThemeName.has_value(), "Unistyles: One of your stylesheets is trying to get the theme, but no theme has been selected yet. Did you forget to select an initial theme?");
 
     auto it = this->_jsThemes.find(_currentThemeName.value());
 
-    helpers::assertThat(*_rt, it != this->_jsThemes.end(), "you're trying to get theme '" + _currentThemeName.value() + "', but it was not registered. Did you forget to register it with StyleSheet.configure?");
+    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(), "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
@@ -88,8 +100,14 @@ int core::UnistylesState::parseColor(jsi::Value& maybeColor) {
         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())) {
+        // we must convert it to uint32_t first, otherwise color will be broken
+        uint32_t color = this->_processColorFn.get()->call(*_rt, colorString).asNumber();
+        
+        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/HybridShadowRegistry.cpp

@@ -4,27 +4,29 @@ 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, "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));
+    auto rawArguments = args[3].asObject(rt).asArray(rt);
+    std::vector<folly::dynamic> arguments = helpers::parseDynamicFunctionArguments(rt, rawArguments);
+
     auto& registry = core::UnistylesRegistry::get();
-    
-    registry.linkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper);
-    
+
+    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, "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();
 }