react-native-unistyles 3.0.0-beta.4 → 3.0.0-beta.6

package/cxx/core/UnistyleWrapper.h

@@ -21,6 +21,7 @@ struct UnistyleWrapper: public jsi::NativeState {
 
 inline static Unistyle::Shared unistyleFromStaticStyleSheet(jsi::Runtime& rt, jsi::Object& value) {
     auto exoticUnistyle = std::make_shared<Unistyle>(
+        helpers::HashGenerator::generateHash(helpers::EXOTIC_STYLE_KEY),
         UnistyleType::Object,
         helpers::EXOTIC_STYLE_KEY,
         value,
@@ -32,56 +33,63 @@ inline static Unistyle::Shared unistyleFromStaticStyleSheet(jsi::Runtime& rt, js
     return exoticUnistyle;
 }
 
-inline static std::vector<Unistyle::Shared> unistylesFromNonExistentNativeState(jsi::Runtime& rt, jsi::Object& value) {
-    auto hasUnistyleName = value.hasProperty(rt, helpers::NAME_STYLE_KEY.c_str());
-
-    // return wrapped RN/inline style
-    if (!hasUnistyleName) {
-        return {unistyleFromStaticStyleSheet(rt, value)};
-    }
+inline static std::vector<std::string> getUnistylesHashKeys(jsi::Runtime& rt, jsi::Object& object) {
+    std::vector<std::string> matchingKeys{};
+    const std::string prefix = "unistyles-";
 
-    throw jsi::JSError(rt, R"(Unistyles: Style is not bound!
+    auto propertyNames = object.getPropertyNames(rt);
+    size_t length = propertyNames.length(rt);
 
-Potential reasons:
-- You likely used the spread operator on a Unistyle style outside of a JSX component
+    for (size_t i = 0; i < length; i++) {
+        auto propertyName = propertyNames.getValueAtIndex(rt, i).getString(rt);
+        std::string key = propertyName.utf8(rt);
 
-If you need to merge styles, do it within the style prop of your JSX component:
+        if (key.compare(0, prefix.length(), prefix) == 0) {
+            matchingKeys.push_back(key);
+        }
+    }
 
-style={{...styles.container, ...styles.otherProp}}
-or
-style={[styles.container, styles.otherProp]}
+    return matchingKeys;
+}
 
-If you pass computed style prop to component use array syntax:
+inline static std::vector<Unistyle::Shared> unistylesFromHashKeys(jsi::Runtime& rt, jsi::Object& object, std::vector<std::string> keys) {
+    std::vector<Unistyle::Shared> unistyles{};
+    auto& registry = UnistylesRegistry::get();
 
-customStyleProp={[styles.container, styles.otherProp]}
+    for (auto& key: keys) {
+        unistyles.emplace_back(registry.getUnistyleById(rt, key));
+    }
 
-Copying a Unistyle style outside of a JSX element will remove its internal C++ state, leading to unexpected behavior.)");
+    return unistyles;
 }
 
-inline static jsi::Object generateUnistylesPrototype(
-    jsi::Runtime& rt,
-    std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime,
-    Unistyle::Shared unistyle,
-    std::optional<Variants> variants,
-    std::optional<jsi::Array> arguments
-) {
-    // add prototype metadata for createUnistylesComponent
-    auto proto = jsi::Object(rt);
-    auto hostFn = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forUtf8(rt, "getStyle"), 0, [unistyle, unistylesRuntime](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count){
-        auto variants = helpers::variantsToPairs(rt, thisValue.asObject(rt).getProperty(rt, "variants").asObject(rt));
-        auto arguments = helpers::parseDynamicFunctionArguments(rt, thisValue.asObject(rt).getProperty(rt, "arguments").asObject(rt).asArray(rt));
-
-        parser::Parser(unistylesRuntime).rebuildUnistyle(rt, unistyle->parent, unistyle, variants, std::make_optional<std::vector<folly::dynamic>>(arguments));
+inline static std::vector<Unistyle::Shared> unistylesFromNonExistentNativeState(jsi::Runtime& rt, jsi::Object& value) {
+    auto unistyleHashKeys = getUnistylesHashKeys(rt, value);
 
-        return jsi::Value(rt, unistyle->parsedStyle.value()).asObject(rt);
+    // return wrapped RN/inline style
+    if (unistyleHashKeys.empty()) {
+        return {unistyleFromStaticStyleSheet(rt, value)};
+    }
+
+    // last chance to fallback and get unistyle based on hash
+    auto unistyles = unistylesFromHashKeys(rt, value, unistyleHashKeys);
+    auto areValid = std::all_of(unistyles.begin(), unistyles.end(), [](Unistyle::Shared unistyle){
+        return unistyle != nullptr;
     });
 
-    proto.setProperty(rt, "getStyle", std::move(hostFn));
-    proto.setProperty(rt, "arguments", arguments.has_value() ? std::move(arguments.value()) : jsi::Array(rt, 0));
-    proto.setProperty(rt, "variants", variants.has_value() ? helpers::pairsToVariantsValue(rt, variants.value()) : jsi::Object(rt));
-    proto.setProperty(rt, helpers::STYLE_DEPENDENCIES.c_str(), helpers::dependenciesToJSIArray(rt, unistyle->dependencies));
+    if (!areValid) {
+        throw jsi::JSError(rt, R"(Unistyles: Style is not bound!
 
-    return proto;
+You likely altered unistyle hash key and we're not able to recover C++ state attached to this node.)");
+    }
+    
+    // someone merged unistyles, and will be warned in JS
+    // the best we can do is to return first unistyle
+    if (unistyles.size() > 1) {
+        return {unistyles.at(0)};
+    }
+    
+    return unistyles;
 }
 
 inline static std::vector<Unistyle::Shared> unistyleFromValue(jsi::Runtime& rt, const jsi::Value& value) {
@@ -116,28 +124,65 @@ inline static std::vector<Unistyle::Shared> unistyleFromValue(jsi::Runtime& rt,
     return unistyles;
 }
 
-inline static jsi::Value valueFromUnistyle(jsi::Runtime& rt, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, Unistyle::Shared unistyle, Variants& variants) {
+inline static jsi::Value objectFromUnistyle(jsi::Runtime& rt, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, Unistyle::Shared unistyle, Variants& variants, std::optional<jsi::Array> arguments) {
     auto wrappedUnistyle = std::make_shared<UnistyleWrapper>(unistyle);
+    auto unistyleID = jsi::PropNameID::forUtf8(rt, unistyle->unid);
 
-    if (unistyle->type == UnistyleType::Object) {
-        jsi::Object obj = jsi::Object(rt);
+    jsi::Object obj = jsi::Object(rt);
 
-        obj.setNativeState(rt, std::move(wrappedUnistyle));
-        obj.setProperty(rt, helpers::NAME_STYLE_KEY.c_str(), jsi::String::createFromUtf8(rt, unistyle->styleKey));
+    obj.setNativeState(rt, std::move(wrappedUnistyle));
 
-        helpers::defineHiddenProperty(rt, obj, helpers::STYLE_DEPENDENCIES.c_str(), helpers::dependenciesToJSIArray(rt, unistyle->dependencies));
-        helpers::mergeJSIObjects(rt, obj, unistyle->parsedStyle.value());
+    auto secrets = jsi::Object(rt);
 
-        obj.setProperty(rt, "__proto__", generateUnistylesPrototype(rt, unistylesRuntime, unistyle, variants, std::nullopt));
+    auto parsedArguments = arguments.has_value()
+        ? helpers::parseDynamicFunctionArguments(rt, arguments.value())
+        : std::optional<std::vector<folly::dynamic>>{};
+    
+    if (arguments.has_value()) {
+        // this is required for HybridShadowRegistry::link
+        helpers::defineHiddenProperty(rt, secrets, helpers::ARGUMENTS.c_str(), arguments.value());
+    }
+
+    // this is required for HybridShadowRegistry::link
+    helpers::defineHiddenProperty(rt, secrets, helpers::STYLESHEET_VARIANTS.c_str(), helpers::variantsToValue(rt, variants));
+
+    // this is required for withUnistyles
+    helpers::defineHiddenProperty(rt, secrets, helpers::STYLE_DEPENDENCIES.c_str(), helpers::dependenciesToJSIArray(rt, unistyle->dependencies));
+    
+    // this is required for withUnistyles
+    auto hostFn = jsi::Function::createFromHostFunction(
+        rt,
+        jsi::PropNameID::forUtf8(rt, helpers::GET_STYLES.c_str()),
+        0,
+        [unistyle, unistylesRuntime, variants, parsedArguments](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count
+    ) {
+        parser::Parser(unistylesRuntime).rebuildUnistyle(rt, unistyle, variants, parsedArguments);
+
+        return jsi::Value(rt, unistyle->parsedStyle.value()).asObject(rt);
+    });
+    
+    helpers::defineHiddenProperty(rt, secrets, helpers::GET_STYLES.c_str(), std::move(hostFn));
 
-        return obj;
+    obj.setProperty(rt, unistyleID, secrets);
+
+    helpers::mergeJSIObjects(rt, obj, unistyle->parsedStyle.value());
+
+    return obj;
+}
+
+inline static jsi::Value valueFromUnistyle(jsi::Runtime& rt, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, Unistyle::Shared unistyle, Variants& variants) {
+    if (unistyle->type == UnistyleType::Object) {
+        return objectFromUnistyle(rt, unistylesRuntime, unistyle, variants, std::nullopt);
     }
 
+    auto wrappedUnistyle = std::make_shared<UnistyleWrapper>(unistyle);
+    auto unistyleID = jsi::PropNameID::forUtf8(rt, unistyle->unid);
+
     auto unistyleFn = std::dynamic_pointer_cast<UnistyleDynamicFunction>(unistyle);
     auto hostFn = jsi::Value(rt, unistyleFn->proxiedFunction.value()).asObject(rt).asFunction(rt);
 
     hostFn.setNativeState(rt, std::move(wrappedUnistyle));
-    hostFn.setProperty(rt, helpers::NAME_STYLE_KEY.c_str(), jsi::String::createFromUtf8(rt, unistyleFn->styleKey));
+    hostFn.setProperty(rt, unistyleID, jsi::Object(rt));
 
     return std::move(hostFn);
 }

package/cxx/core/UnistylesRegistry.cpp

@@ -75,7 +75,7 @@ void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
 ) {
     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);
     });
@@ -86,6 +86,27 @@ void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
     this->trafficController.resumeUnistylesTraffic();
 }
 
+void core::UnistylesRegistry::removeDuplicatedUnistyles(jsi::Runtime& rt, const ShadowNodeFamily *shadowNodeFamily, std::vector<core::Unistyle::Shared>& unistyles) {
+    auto targetFamilyUnistyles = this->_shadowRegistry[&rt][shadowNodeFamily];
+
+    unistyles.erase(
+        std::remove_if(
+            unistyles.begin(),
+            unistyles.end(),
+            [&targetFamilyUnistyles](const core::Unistyle::Shared& unistyle) {
+                return std::any_of(
+                    targetFamilyUnistyles.begin(),
+                    targetFamilyUnistyles.end(),
+                    [&unistyle](const std::shared_ptr<core::UnistyleData>& data) {
+                        return data->unistyle == unistyle;
+                    }
+                );
+            }
+        ),
+        unistyles.end()
+    );
+}
+
 void core::UnistylesRegistry::unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, const ShadowNodeFamily* shadowNodeFamily) {
     this->_shadowRegistry[&rt].erase(shadowNodeFamily);
     this->trafficController.removeShadowNode(shadowNodeFamily);
@@ -159,7 +180,7 @@ std::vector<std::shared_ptr<core::StyleSheet>> core::UnistylesRegistry::getStyle
                                       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;
@@ -173,7 +194,7 @@ std::vector<std::shared_ptr<core::StyleSheet>> core::UnistylesRegistry::getStyle
         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(),
@@ -181,10 +202,10 @@ std::vector<std::shared_ptr<core::StyleSheet>> core::UnistylesRegistry::getStyle
                         return std::find(unistylesDependencies.begin(), unistylesDependencies.end(), dep) != unistylesDependencies.end();
                     }
                 );
-                
+
                 if (hasAnyOfDependencies) {
                     stylesheetsToRefresh.emplace_back(styleSheet);
-                    
+
                     return;
                 }
             }
@@ -198,18 +219,26 @@ std::vector<std::shared_ptr<core::StyleSheet>> core::UnistylesRegistry::getStyle
     return stylesheetsToRefresh;
 }
 
-const core::Variants& core::UnistylesRegistry::getScopedVariants() {
-    return this->_scopedVariants;
+core::Unistyle::Shared core::UnistylesRegistry::getUnistyleById(jsi::Runtime& rt, std::string unistyleID) {
+    for (auto& pair: this->_styleSheetRegistry[&rt]) {
+        auto [_, stylesheet] = pair;
+
+        for (auto unistylePair: stylesheet->unistyles) {
+            auto [_, unistyle] = unistylePair;
+
+            if (unistyle->unid == unistyleID) {
+                return unistyle;
+            }
+        }
+    }
+
+    return nullptr;
 }
 
 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

@@ -27,6 +27,8 @@ struct UnistylesRegistry: public StyleSheetRegistry {
 
     UnistylesRegistry(const UnistylesRegistry&) = delete;
     UnistylesRegistry(const UnistylesRegistry&&) = delete;
+    
+    bool shouldUsePointsForBreakpoints = false;
 
     void registerTheme(jsi::Runtime& rt, std::string name, jsi::Value& theme);
     void registerBreakpoints(jsi::Runtime& rt, std::vector<std::pair<std::string, double>>& sortedBreakpoints);
@@ -43,15 +45,14 @@ struct UnistylesRegistry: public StyleSheetRegistry {
     DependencyMap buildDependencyMap(jsi::Runtime& rt, std::vector<UnistyleDependency>& deps);
     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 removeDuplicatedUnistyles(jsi::Runtime& rt, const ShadowNodeFamily* shadowNodeFamily, std::vector<core::Unistyle::Shared>& unistyles);
     void setScopedTheme(std::optional<std::string> themeName);
+    core::Unistyle::Shared getUnistyleById(jsi::Runtime& rt, std::string unistyleID);
 
 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{};

package/cxx/hybridObjects/HybridNavigationBar.cpp

@@ -1,13 +1,13 @@
 #include "HybridNavigationBar.h"
 
 void HybridNavigationBar::setHidden(bool isHidden) {
-    this->_nativePlatform.setNavigationBarHidden(isHidden);
+    this->_nativePlatform->setNavigationBarHidden(isHidden);
 };
 
 double HybridNavigationBar::getWidth() {
-    return this->_nativePlatform.getNavigationBarDimensions().width;
+    return this->_nativePlatform->getNavigationBarDimensions().width;
 }
 
 double HybridNavigationBar::getHeight() {
-    return this->_nativePlatform.getNavigationBarDimensions().height;
+    return this->_nativePlatform->getNavigationBarDimensions().height;
 }

package/cxx/hybridObjects/HybridNavigationBar.h

@@ -7,12 +7,12 @@
 using namespace margelo::nitro::unistyles;
 
 struct HybridNavigationBar: public HybridUnistylesNavigationBarSpec {
-    HybridNavigationBar(Unistyles::HybridNativePlatformSpecCxx nativePlatform): HybridObject(TAG), _nativePlatform{nativePlatform} {}
+    HybridNavigationBar(std::shared_ptr<HybridNativePlatformSpec> nativePlatform): HybridObject(TAG), _nativePlatform{nativePlatform} {}
 
     void setHidden(bool isHidden) override;
     double getWidth() override;
     double getHeight() override;
 
 private:
-    Unistyles::HybridNativePlatformSpecCxx _nativePlatform;
+    std::shared_ptr<HybridNativePlatformSpec> _nativePlatform;
 };

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -7,30 +7,38 @@ jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisVa
     helpers::assertThat(rt, count == 2, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected 2 arguments.");
 
     ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
+
     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());
+    // this is special case for Animated, and prevents appending same unistyles to node
+    registry.removeDuplicatedUnistyles(rt, &shadowNodeWrapper->getFamily(), unistyleWrappers);
 
-            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)));
+    if (unistyleWrappers.empty()) {
+        return jsi::Value::undefined();
+    }
 
-            continue;
+    for (size_t i = 0; i < unistyleWrappers.size(); i++) {
+        if (unistyleWrappers[i]->type == core::UnistyleType::DynamicFunction) {
+            try {
+                auto rawStyle = args[1].asObject(rt).asArray(rt).getValueAtIndex(rt, i);
+                auto rawStyleObj = rawStyle.getObject(rt);
+                auto unistyleHashKeys = core::getUnistylesHashKeys(rt, rawStyleObj);
+                auto secrets = rawStyleObj.getProperty(rt, unistyleHashKeys.at(0).c_str()).asObject(rt);
+                auto secretArguments = secrets.getProperty(rt, helpers::ARGUMENTS.c_str()).asObject(rt).asArray(rt);
+
+                arguments.push_back(helpers::parseDynamicFunctionArguments(rt, secretArguments));
+
+                continue;
+            } catch (...) {
+                arguments.push_back({});
+            }
         }
 
         arguments.push_back({});
     }
-    
+
     auto scopedTheme = registry.getScopedTheme();
 
     // check if scope theme exists
@@ -47,9 +55,23 @@ jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisVa
     // create unistyleData based on wrappers
     for (size_t i = 0; i < unistyleWrappers.size(); i++) {
         core::Unistyle::Shared& unistyle = unistyleWrappers[i];
+        auto rawStyle = args[1].asObject(rt).asArray(rt).getValueAtIndex(rt, i);
+        auto rawStyleObj = rawStyle.getObject(rt);
+        auto unistyleHashKeys = core::getUnistylesHashKeys(rt, rawStyleObj);
+        core::Variants variants{};
+
+        if (unistyleHashKeys.size() == 1) {
+            auto secrets = rawStyleObj.getProperty(rt, unistyleHashKeys.at(0).c_str()).asObject(rt);
+            auto hasVariants = secrets.hasProperty(rt, helpers::STYLESHEET_VARIANTS.c_str());
+
+            if (hasVariants) {
+                variants = helpers::variantsToPairs(rt, secrets.getProperty(rt, helpers::STYLESHEET_VARIANTS.c_str()).asObject(rt));
+            }
+        }
+
         std::shared_ptr<core::UnistyleData> unistyleData = std::make_shared<core::UnistyleData>(
             unistyle,
-            registry.getScopedVariants(),
+            variants,
             arguments[i],
             scopedTheme
         );
@@ -62,9 +84,6 @@ jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisVa
 
             // 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);
@@ -91,25 +110,9 @@ jsi::Value HybridShadowRegistry::unlink(jsi::Runtime &rt, const jsi::Value &this
     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();
-
-    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()) {
@@ -127,17 +130,8 @@ jsi::Value HybridShadowRegistry::setScopedTheme(jsi::Runtime &rt, const jsi::Val
 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();
 }
-
-jsi::Value HybridShadowRegistry::getVariants(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
-    auto& registry = core::UnistylesRegistry::get();
-    auto maybeScopedVariants = registry.getScopedVariants();
-    
-    return maybeScopedVariants.size() > 0
-        ? helpers::variantsToValue(rt, maybeScopedVariants)
-        : jsi::Value::undefined();
-}

package/cxx/hybridObjects/HybridShadowRegistry.h

@@ -20,10 +20,6 @@ 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,
@@ -32,10 +28,6 @@ struct HybridShadowRegistry: public HybridUnistylesShadowRegistrySpec {
                             const jsi::Value& thisValue,
                             const jsi::Value* args,
                             size_t count);
-    jsi::Value getVariants(jsi::Runtime& rt,
-                            const jsi::Value& thisValue,
-                            const jsi::Value* args,
-                            size_t count);
 
     void loadHybridMethods() override {
         HybridUnistylesShadowRegistrySpec::loadHybridMethods();
@@ -43,10 +35,8 @@ struct HybridShadowRegistry: public HybridUnistylesShadowRegistrySpec {
         registerHybrids(this, [](Prototype& prototype) {
             prototype.registerRawHybridMethod("link", 2, &HybridShadowRegistry::link);
             prototype.registerRawHybridMethod("unlink", 1, &HybridShadowRegistry::unlink);
-            prototype.registerRawHybridMethod("selectVariants", 1, &HybridShadowRegistry::selectVariants);
             prototype.registerRawHybridMethod("setScopedTheme", 1, &HybridShadowRegistry::setScopedTheme);
             prototype.registerRawHybridMethod("getScopedTheme", 0, &HybridShadowRegistry::getScopedTheme);
-            prototype.registerRawHybridMethod("getVariants", 0, &HybridShadowRegistry::getVariants);
         });
     };
 

package/cxx/hybridObjects/HybridStatusBar.cpp

@@ -1,13 +1,13 @@
 #include "HybridStatusBar.h"
 
 double HybridStatusBar::getWidth() {
-    return this->_nativePlatform.getStatusBarDimensions().width;
+    return this->_nativePlatform->getStatusBarDimensions().width;
 }
 
 double HybridStatusBar::getHeight() {
-    return this->_nativePlatform.getStatusBarDimensions().height;
+    return this->_nativePlatform->getStatusBarDimensions().height;
 }
 
 void HybridStatusBar::setHidden(bool isHidden) {
-    return this->_nativePlatform.setStatusBarHidden(isHidden);
+    this->_nativePlatform->setStatusBarHidden(isHidden);
 }

package/cxx/hybridObjects/HybridStatusBar.h

@@ -7,12 +7,12 @@
 using namespace margelo::nitro::unistyles;
 
 struct HybridStatusBar: public HybridUnistylesStatusBarSpec {
-    HybridStatusBar(Unistyles::HybridNativePlatformSpecCxx nativePlatform): HybridObject(TAG), _nativePlatform{nativePlatform} {}
+    HybridStatusBar(std::shared_ptr<HybridNativePlatformSpec> nativePlatform): HybridObject(TAG), _nativePlatform{nativePlatform} {}
 
     double getWidth() override;
     double getHeight() override;
     void setHidden(bool isHidden) override;
 
 private:
-    Unistyles::HybridNativePlatformSpecCxx _nativePlatform;
+    std::shared_ptr<HybridNativePlatformSpec> _nativePlatform;
 };