react-native-unistyles 3.0.0-alpha.9 → 3.0.0-beta.2

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,38 +61,37 @@ 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<folly::dynamic>& arguments
+    std::vector<std::shared_ptr<UnistyleData>>& unistylesData
 ) {
-    if (!this->_shadowRegistry.contains(shadowNodeFamily)) {
-        this->_shadowRegistry[shadowNodeFamily] = {};
-    }
+    shadow::ShadowLeafUpdates updates;
+    auto parser = parser::Parser(nullptr);
+    
+    std::for_each(unistylesData.begin(), unistylesData.end(), [this, &rt, shadowNodeFamily](std::shared_ptr<UnistyleData> unistyleData){
+        this->_shadowRegistry[&rt][shadowNodeFamily].emplace_back(unistyleData);
+    });
 
-    this->_shadowRegistry[shadowNodeFamily].emplace_back(std::make_shared<UnistyleData>(unistyle, variants, arguments));
+    updates[shadowNodeFamily] = parser.parseStylesToShadowTreeStyles(rt, unistylesData);
+
+    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::shared_ptr<UnistyleData> unistyleData){
-        return unistyleData->unistyle == 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);
     }
 }
 
@@ -105,13 +105,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();
                 }
@@ -121,42 +119,97 @@ 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& unistyleData : unistyles) {
-                    if (unistyle != unistyleData->unistyle) {
-                        continue;
-                    }
+            break;
+        }
+    }
 
-                    dependencyMap[styleSheet][family].emplace_back(unistyleData);
-                }
+    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) {
+                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& unistyleData : unistyles) {
-                    if (unistyle != unistyleData->unistyle) {
-                        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(unistyleData);
+        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;
+}
+
+const core::Variants& core::UnistylesRegistry::getScopedVariants() {
+    return this->_scopedVariants;
+}
+
+const std::optional<std::string> core::UnistylesRegistry::getScopedTheme() {
+    return this->_scopedTheme;
+}
+
+void core::UnistylesRegistry::setScopedVariants(core::Variants&& variants) {
+    this->_scopedVariants = std::move(variants);
+}
+
+void core::UnistylesRegistry::setScopedTheme(std::optional<std::string> themeName) {
+    this->_scopedTheme = std::move(themeName);
 }

package/cxx/core/UnistylesRegistry.h

@@ -11,6 +11,7 @@
 #include "StyleSheet.h"
 #include "Unistyle.h"
 #include "UnistyleData.h"
+#include "ShadowTrafficController.h"
 
 namespace margelo::nitro::unistyles::core {
 
@@ -19,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<std::shared_ptr<UnistyleData>>>
->;
+using DependencyMap = std::unordered_map<const ShadowNodeFamily*, std::vector<std::shared_ptr<UnistyleData>>>;
 
 struct UnistylesRegistry: public StyleSheetRegistry {
     static UnistylesRegistry& get();
@@ -30,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);
@@ -38,21 +36,29 @@ struct UnistylesRegistry: public StyleSheetRegistry {
 
     UnistylesState& getState(jsi::Runtime& rt);
     void createState(jsi::Runtime& rt);
-    void linkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared, Variants& variants, std::vector<folly::dynamic>&);
-    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<std::shared_ptr<UnistyleData>>& unistylesData);
+    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{};
+    const core::Variants& getScopedVariants();
+    const std::optional<std::string> getScopedTheme();
+    void setScopedVariants(core::Variants&& variants);
+    void setScopedTheme(std::optional<std::string> themeName);
 
 private:
     UnistylesRegistry() = default;
-
+    
+    core::Variants _scopedVariants{};
+    std::optional<std::string> _scopedTheme{};
     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::shared_ptr<UnistyleData>>> _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,30 +4,131 @@ 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 == 4, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected 4 arguments.");
-    
+    helpers::assertThat(rt, count == 2, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected 2 arguments.");
+
     ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
-    core::Unistyle::Shared unistyleWrapper = 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);
-    
+    std::vector<core::Unistyle::Shared> unistyleWrappers = core::unistyleFromValue(rt, args[1]);
+    std::vector<std::vector<folly::dynamic>> arguments;
     auto& registry = core::UnistylesRegistry::get();
+
+    for (size_t i = 0; i < unistyleWrappers.size(); i++) {
+        if (unistyleWrappers[i]->type == core::UnistyleType::DynamicFunction) {
+            auto rawStyle = args[1].asObject(rt).asArray(rt).getValueAtIndex(rt, i);
+
+            helpers::assertThat(rt, rawStyle.isObject(), "Unistyles: Dynamic function is not bound!");
+
+            auto maybeSecrets = rawStyle.getObject(rt).getProperty(rt, helpers::SECRETS.c_str());
+
+            helpers::assertThat(rt, maybeSecrets.isObject(), "Unistyles: Dynamic function is not bound!");
+
+            auto secrets = maybeSecrets.asObject(rt).getProperty(rt, helpers::ARGUMENTS.c_str());
+
+            arguments.push_back(helpers::parseDynamicFunctionArguments(rt, secrets.asObject(rt).asArray(rt)));
+
+            continue;
+        }
+
+        arguments.push_back({});
+    }
     
-    registry.linkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper, variants, arguments);
-    
+    auto scopedTheme = registry.getScopedTheme();
+
+    // check if scope theme exists
+    if (scopedTheme.has_value()) {
+        auto themeName = scopedTheme.value();
+
+        helpers::assertThat(rt, registry.getState(rt).hasTheme(themeName), "Unistyles: You're trying to use scoped theme '" + themeName + "' but it wasn't registered.");
+    }
+
+    auto parser = parser::Parser(this->_unistylesRuntime);
+    auto parsedStyleSheet = jsi::Value::undefined();
+    std::vector<std::shared_ptr<core::UnistyleData>> unistylesData{};
+
+    // create unistyleData based on wrappers
+    for (size_t i = 0; i < unistyleWrappers.size(); i++) {
+        core::Unistyle::Shared& unistyle = unistyleWrappers[i];
+        std::shared_ptr<core::UnistyleData> unistyleData = std::make_shared<core::UnistyleData>(
+            unistyle,
+            registry.getScopedVariants(),
+            arguments[i],
+            scopedTheme
+        );
+
+        // before linking we need to check if given unistyle is affected by scoped theme
+        if (scopedTheme.has_value()) {
+            if (parsedStyleSheet.isUndefined()) {
+                parsedStyleSheet = parser.getParsedStyleSheetForScopedTheme(rt, unistyle, scopedTheme.value());
+            }
+
+            // if so we need to force update
+            parser.rebuildUnistyleWithScopedTheme(rt, parsedStyleSheet, unistyleData);
+        } else {
+            // for other styles, not scoped to theme we need to compute variants value
+            parser.rebuildUnistyleWithVariants(rt, unistyleData);
+        }
+
+        unistylesData.emplace_back(unistyleData);
+    }
+
+    registry.linkShadowNodeWithUnistyle(
+        rt,
+        &shadowNodeWrapper->getFamily(),
+        unistylesData
+    );
+
     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 argument.");
+
     ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
-    core::Unistyle::Shared unistyleWrapper = core::unistyleFromValue(rt, args[1]);
+
+    auto& registry = core::UnistylesRegistry::get();
+
+    registry.unlinkShadowNodeWithUnistyles(rt, &shadowNodeWrapper->getFamily());
+
+    return jsi::Value::undefined();
+}
+
+jsi::Value HybridShadowRegistry::selectVariants(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    helpers::assertThat(rt, count == 1, "Unistyles: Invalid babel transform 'ShadowRegistry selectVariants' expected 1 arguments.");
     
     auto& registry = core::UnistylesRegistry::get();
 
-    registry.unlinkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper);
+    if (args[0].isUndefined()) {
+        registry.setScopedVariants({});
+    }
+
+    if (args[0].isObject()) {
+        registry.setScopedVariants(helpers::variantsToPairs(rt, args[0].asObject(rt)));
+    }
+
+    return jsi::Value::undefined();
+}
+
+jsi::Value HybridShadowRegistry::setScopedTheme(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    helpers::assertThat(rt, count == 1, "Unistyles: setScopedTheme expected 1 argument.");
     
+    auto& registry = core::UnistylesRegistry::get();
+
+    if (args[0].isUndefined()) {
+
+        registry.setScopedTheme(std::nullopt);
+    }
+
+    if (args[0].isString()) {
+        registry.setScopedTheme(args[0].asString(rt).utf8(rt));
+    }
+
     return jsi::Value::undefined();
 }
+
+jsi::Value HybridShadowRegistry::getScopedTheme(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    auto& registry = core::UnistylesRegistry::get();
+    auto maybeScopedTheme = registry.getScopedTheme();
+    
+    return maybeScopedTheme.has_value()
+        ? jsi::String::createFromUtf8(rt, maybeScopedTheme.value())
+        : jsi::Value::undefined();
+}

package/cxx/hybridObjects/HybridShadowRegistry.h

@@ -9,8 +9,9 @@
 namespace margelo::nitro::unistyles {
 
 struct HybridShadowRegistry: public HybridUnistylesShadowRegistrySpec {
-    HybridShadowRegistry(): HybridObject(TAG) {}
-    
+    HybridShadowRegistry(std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
+        : HybridObject(TAG), _unistylesRuntime{unistylesRuntime} {}
+
     jsi::Value link(jsi::Runtime& rt,
                             const jsi::Value& thisValue,
                             const jsi::Value* args,
@@ -19,6 +20,18 @@ struct HybridShadowRegistry: public HybridUnistylesShadowRegistrySpec {
                             const jsi::Value& thisValue,
                             const jsi::Value* args,
                             size_t count);
+    jsi::Value selectVariants(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
+    jsi::Value setScopedTheme(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
+    jsi::Value getScopedTheme(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
 
     void loadHybridMethods() override {
         HybridUnistylesShadowRegistrySpec::loadHybridMethods();
@@ -26,8 +39,14 @@ struct HybridShadowRegistry: public HybridUnistylesShadowRegistrySpec {
         registerHybrids(this, [](Prototype& prototype) {
             prototype.registerRawHybridMethod("link", 2, &HybridShadowRegistry::link);
             prototype.registerRawHybridMethod("unlink", 2, &HybridShadowRegistry::unlink);
+            prototype.registerRawHybridMethod("selectVariants", 2, &HybridShadowRegistry::selectVariants);
+            prototype.registerRawHybridMethod("setScopedTheme", 2, &HybridShadowRegistry::setScopedTheme);
+            prototype.registerRawHybridMethod("getScopedTheme", 2, &HybridShadowRegistry::getScopedTheme);
         });
     };
+
+private:
+    std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
 };
 
 }

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;
 };