react-native-unistyles 3.0.0-beta.1 → 3.0.0-beta.2

package/README.md

@@ -1,4 +1,4 @@
-[<img alt="react-native-unistyles" src="assets/banner.png">](https://unistyl.es/)
+[<img alt="react-native-unistyles" src="assets/banner3.png">](https://unistyl.es/)
 
 ![GitHub package.json version](https://img.shields.io/github/package-json/v/jpudysz/react-native-unistyles?style=for-the-badge)
 [![npm downloads](https://img.shields.io/npm/dm/react-native-unistyles?style=for-the-badge)](https://www.npmjs.com/package/react-native-unistyles)
@@ -59,12 +59,12 @@ Then follow [installation guides](https://unistyl.es/v3/start/getting-started) f
 <a href="https://github.com/happyfloat">
      <img src="https://avatars.githubusercontent.com/u/186333704?s=200&v=4" height="70px" width="70px" alt="happyfloat" />
 </a>
-<a href="https://github.com">
-     <img src="https://avatars.githubusercontent.com/u/138339?v=4" height="70px" width="70px" alt="anonymous" />
-</a>
 <a href="https://github.com/hyoban">
      <img src="https://avatars.githubusercontent.com/u/38493346?v=4" height="70px" width="70px" alt="hyoban" />
 </a>
+<a href="https://github.com/oscklm">
+     <img src="https://avatars.githubusercontent.com/u/22825865?v=4" height="70px" width="70px" alt="oscklm" />
+</a>
 
 ## Past sponsors
 

package/Unistyles.podspec

@@ -26,7 +26,13 @@ Pod::Spec.new do |s|
     "ios/Unistyles.h"
   ]
 
-  load 'nitrogen/generated/ios/Unistyles+autolinking.rb'
+  if ENV["USE_FRAMEWORKS"]
+    s.dependency "React-Core"
+    add_dependency(s, "React-jsinspector", :framework_name => "jsinspector_modern")
+    add_dependency(s, "React-rendererconsistency", :framework_name => "React_rendererconsistency")
+  end
+
+  load "nitrogen/generated/ios/Unistyles+autolinking.rb"
   add_nitrogen_files(s)
 
   install_modules_dependencies(s)

package/android/build.gradle

@@ -12,6 +12,11 @@ buildscript {
     }
 }
 
+def reactNativeArchitectures() {
+    def value = rootProject.getProperties().get("reactNativeArchitectures")
+    return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
 apply plugin: 'com.android.library'
 apply plugin: 'org.jetbrains.kotlin.android'
 apply from: '../nitrogen/generated/android/unistyles+autolinking.gradle'
@@ -41,6 +46,7 @@ android {
         externalNativeBuild {
             cmake {
                 arguments "-DANDROID_STL=c++_shared"
+                abiFilters (*reactNativeArchitectures())
             }
         }
     }

package/android/src/main/cxx/NativeUnistylesModule.cpp

@@ -64,8 +64,8 @@ jni::local_ref<BindingsInstallerHolder::javaobject> UnistylesModule::getBindings
         HybridObjectRegistry::registerHybridObjectConstructor("UnistylesStyleSheet", [styleSheet]() -> std::shared_ptr<HybridObject>{
             return styleSheet;
         });
-        HybridObjectRegistry::registerHybridObjectConstructor("UnistylesShadowRegistry", []() -> std::shared_ptr<HybridObject>{
-            return std::make_shared<HybridShadowRegistry>();
+        HybridObjectRegistry::registerHybridObjectConstructor("UnistylesShadowRegistry", [unistylesRuntime]() -> std::shared_ptr<HybridObject>{
+            return std::make_shared<HybridShadowRegistry>(unistylesRuntime);
         });
     });
 }

package/cxx/common/Constants.h

@@ -9,5 +9,7 @@ static const std::string STYLE_VARIANTS = "uni__variants";
 static const std::string WEB_STYLE_KEY = "_web";
 static const std::string EXOTIC_STYLE_KEY = "_exotic";
 static const std::string NAME_STYLE_KEY = "__unistyles_name";
+static const std::string SECRETS = "__uni__secrets";
+static const std::string ARGUMENTS = "__uni__args";
 
 }

package/cxx/core/HostStyle.cpp

@@ -22,15 +22,21 @@ jsi::Value HostStyle::get(jsi::Runtime& rt, const jsi::PropNameID& propNameId) {
     if (propertyName == helpers::UNISTYLES_ID) {
         return jsi::Value(this->_styleSheet->tag);
     }
-    
+
     if (propertyName == helpers::ADD_VARIANTS_FN) {
         return this->createAddVariantsProxyFunction(rt);
     }
 
     if (this->_styleSheet->unistyles.contains(propertyName)) {
-        return valueFromUnistyle(rt, this->_unistylesRuntime, this->_styleSheet->unistyles[propertyName], this->_styleSheet->tag);
+        if (this->_styleCache.contains(propertyName)) {
+            return jsi::Value(rt, this->_styleCache[propertyName]);
+        }
+        
+        this->_styleCache[propertyName] = valueFromUnistyle(rt, this->_unistylesRuntime, this->_styleSheet->unistyles[propertyName]);
+        
+        return jsi::Value(rt, this->_styleCache[propertyName]);
     }
-    
+
     if (propertyName == helpers::STYLE_VARIANTS) {
         return helpers::variantsToValue(rt, this->_variants);
     }
@@ -45,17 +51,16 @@ jsi::Function HostStyle::createAddVariantsProxyFunction(jsi::Runtime& rt) {
         helpers::assertThat(rt, count == 1, "Unistyles: useVariants expected to be called with one argument.");
         helpers::assertThat(rt, arguments[0].isObject(), "Unistyles: useVariants expected to be called with object.");
 
-        auto parser = parser::Parser(this->_unistylesRuntime);
         auto pairs = helpers::variantsToPairs(rt, arguments[0].asObject(rt));
 
-        if (pairs == this->_variants) {
+        if (this->hasVariantsSet && pairs == this->_variants) {
             return jsi::Value::undefined();
         }
 
+        // new variants or empty variants
+        this->hasVariantsSet = true;
         this->_variants = pairs;
 
-        parser.rebuildUnistylesWithVariants(rt, this->_styleSheet, this->_variants);
-
         return jsi::Value::undefined();
     });
 }

package/cxx/core/HostStyle.h

@@ -21,9 +21,14 @@ struct JSI_EXPORT HostStyle : public jsi::HostObject {
     jsi::Function createAddVariantsProxyFunction(jsi::Runtime& rt);
 
 private:
+    // to additionally distinguish between empty variants
+    // that are set at the beginning
+    bool hasVariantsSet = false;
+    
     std::shared_ptr<StyleSheet> _styleSheet;
     std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
     std::vector<std::pair<std::string, std::string>> _variants{};
+    std::unordered_map<std::string, jsi::Value> _styleCache{};
 };
 
 }

package/cxx/core/UnistyleData.h

@@ -8,8 +8,8 @@ namespace margelo::nitro::unistyles::core {
 using Variants = std::vector<std::pair<std::string, std::string>>;
 
 struct UnistyleData {
-    UnistyleData(Unistyle::Shared unistyle, const Variants& variants, std::vector<folly::dynamic>& arguments, std::optional<std::string> uniquePressableId)
-        : unistyle{unistyle}, variants(std::move(variants)), dynamicFunctionMetadata{std::move(arguments)}, pressableId{std::move(uniquePressableId)} {}
+    UnistyleData(Unistyle::Shared unistyle, const Variants& variants, std::vector<folly::dynamic>& arguments, std::optional<std::string> scopedTheme)
+        : unistyle{unistyle}, variants(std::move(variants)), dynamicFunctionMetadata{std::move(arguments)}, scopedTheme{scopedTheme} {}
 
     UnistyleData(const UnistyleData&) = delete;
     UnistyleData(UnistyleData&& other) = delete;
@@ -18,7 +18,7 @@ struct UnistyleData {
     core::Variants variants;
     std::optional<jsi::Object> parsedStyle = std::nullopt;
     std::optional<std::vector<folly::dynamic>> dynamicFunctionMetadata = std::nullopt;
-    std::optional<std::string> pressableId = std::nullopt;
+    std::optional<std::string> scopedTheme = std::nullopt;
 };
 
 }

package/cxx/core/UnistyleWrapper.h

@@ -88,35 +88,35 @@ inline static std::vector<Unistyle::Shared> unistyleFromValue(jsi::Runtime& rt,
     if (value.isNull() || !value.isObject()) {
         return {};
     }
-    
+
     auto maybeArray = value.asObject(rt);
-    
+
     helpers::assertThat(rt, maybeArray.isArray(rt), "Unistyles: can't retrieve Unistyle state from node as it's not an array.");
-    
+
     std::vector<Unistyle::Shared> unistyles;
     jsi::Array unistylesArray = maybeArray.asArray(rt);
-    
+
     helpers::iterateJSIArray(rt, unistylesArray, [&rt, &unistyles](size_t index, jsi::Value& value){
         auto obj = value.getObject(rt);
 
         // possible if user used React Native styles or inline styles or did spread styles
         if (!obj.hasNativeState(rt)) {
             auto exoticUnistyles = unistylesFromNonExistentNativeState(rt, obj);
-            
+
             for (auto& exoticUnistyle: exoticUnistyles) {
                 unistyles.emplace_back(exoticUnistyle);
             }
-            
+
             return;
         }
 
         unistyles.emplace_back(value.getObject(rt).getNativeState<UnistyleWrapper>(rt)->unistyle);
     });
-    
+
     return unistyles;
 }
 
-inline static jsi::Value valueFromUnistyle(jsi::Runtime& rt, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, Unistyle::Shared unistyle, int tag) {
+inline static jsi::Value valueFromUnistyle(jsi::Runtime& rt, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, Unistyle::Shared unistyle) {
     auto wrappedUnistyle = std::make_shared<UnistyleWrapper>(unistyle);
 
     if (unistyle->type == UnistyleType::Object) {

package/cxx/core/UnistylesRegistry.cpp

@@ -71,32 +71,16 @@ void core::UnistylesRegistry::updateTheme(jsi::Runtime& rt, std::string& themeNa
 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,
-    std::optional<std::string> uniquePressableId
+    std::vector<std::shared_ptr<UnistyleData>>& unistylesData
 ) {
-    auto parser = parser::Parser(nullptr);
     shadow::ShadowLeafUpdates updates;
+    auto parser = parser::Parser(nullptr);
     
-    for (size_t index = 0; index < unistyles.size(); index++) {
-        Unistyle::Shared unistyle = unistyles[index];
-
-        this->_shadowRegistry[&rt][shadowNodeFamily]
-            .emplace_back(std::make_shared<UnistyleData>(unistyle, variants, arguments[index], uniquePressableId));
-
-        // add or update node for shadow leaf updates
-        // dynamic functions are parsed later
-        if (unistyle->type == UnistyleType::Object) {
-            for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
-                for (const auto& unistyleData : unistyles) {
-                    if (unistyleData->unistyle == unistyle && family == shadowNodeFamily) {
-                        updates[family] = parser.parseStylesToShadowTreeStyles(rt, {unistyleData});
-                    }
-                }
-            }
-        }
-    }
+    std::for_each(unistylesData.begin(), unistylesData.end(), [this, &rt, shadowNodeFamily](std::shared_ptr<UnistyleData> unistyleData){
+        this->_shadowRegistry[&rt][shadowNodeFamily].emplace_back(unistyleData);
+    });
+
+    updates[shadowNodeFamily] = parser.parseStylesToShadowTreeStyles(rt, unistylesData);
 
     this->trafficController.setUpdates(updates);
     this->trafficController.resumeUnistylesTraffic();
@@ -160,13 +144,6 @@ void core::UnistylesRegistry::shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Uni
     for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
         for (const auto& unistyleData : unistyles) {
             if (unistyleData->unistyle == unistyle) {
-                // special case for pressable
-                if (pressableId.has_value() && unistyleData->pressableId.has_value()) {
-                    if (pressableId.value() == unistyleData->pressableId.value()) {
-                        unistyleData->parsedStyle = jsi::Value(rt, unistyle->parsedStyle.value()).asObject(rt);
-                    }
-                }
-                
                 updates[family] = parser.parseStylesToShadowTreeStyles(rt, { unistyleData });
             }
         }
@@ -220,3 +197,19 @@ std::vector<std::shared_ptr<core::StyleSheet>> core::UnistylesRegistry::getStyle
 
     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

@@ -37,16 +37,22 @@ struct UnistylesRegistry: public StyleSheetRegistry {
     UnistylesState& getState(jsi::Runtime& rt);
     void createState(jsi::Runtime& rt);
     std::vector<std::shared_ptr<core::StyleSheet>> getStyleSheetsToRefresh(jsi::Runtime& rt, std::vector<UnistyleDependency>& unistylesDependencies);
-    void linkShadowNodeWithUnistyle(jsi::Runtime& rt, const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>& unistyles, Variants& variants, std::vector<std::vector<folly::dynamic>>&, std::optional<std::string> uniquePressableId);
+    void 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);
     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<jsi::Runtime*, std::unordered_map<const ShadowNodeFamily*, std::vector<const std::shared_ptr<UnistyleData>>>> _shadowRegistry{};

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -4,29 +4,83 @@ 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 == 5, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected 5 arguments.");
+    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]);
-    core::Variants variants = helpers::variantsToPairs(rt, args[2].asObject(rt));
-    jsi::Array rawArguments = args[3].asObject(rt).asArray(rt);
-    std::optional<std::string> uniquePressableId = args[4].isUndefined()
-            ? std::nullopt
-            : std::make_optional<std::string>(args[4].asString(rt).utf8(rt));
     std::vector<std::vector<folly::dynamic>> arguments;
     auto& registry = core::UnistylesRegistry::get();
+
+    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({});
+    }
     
-    helpers::iterateJSIArray(rt, rawArguments, [&rt, &arguments](size_t index, jsi::Value& value){
-        arguments.push_back(helpers::parseDynamicFunctionArguments(rt, value.asObject(rt).asArray(rt)));
-    });
-    
-    registry.linkShadowNodeWithUnistyle(rt, &shadowNodeWrapper->getFamily(), unistyleWrappers, variants, arguments, uniquePressableId);
+    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 == 1, "Unistyles: Invalid babel transform 'ShadowRegistry unlink' expected 1 arguments.");
+    helpers::assertThat(rt, count == 1, "Unistyles: Invalid babel transform 'ShadowRegistry unlink' expected 1 argument.");
 
     ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
 
@@ -36,3 +90,45 @@ 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()) {
+
+        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/HybridUnistylesRuntime.cpp

@@ -130,6 +130,10 @@ jsi::Value HybridUnistylesRuntime::getTheme(jsi::Runtime &rt, const jsi::Value &
     auto& state = core::UnistylesRegistry::get().getState(*_rt);
 
     if (count == 1) {
+        if (args[0].isUndefined()) {
+            return state.getCurrentJSTheme();
+        }
+        
         helpers::assertThat(rt, args[0].isString(), "UnistylesRuntime.getTheme expected to be called with string.");
 
         auto themeName = args[0].asString(rt).utf8(rt);