react-native-unistyles 3.1.0 → 3.2.0

package/cxx/core/UnistylesState.cpp

@@ -12,7 +12,9 @@ bool core::UnistylesState::hasAdaptiveThemes() {
 }
 
 void core::UnistylesState::setTheme(std::string themeName) {
-    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 (!helpers::vecContainsKeys(this->_registeredThemeNames, {themeName})) {
+        throw std::runtime_error("Unistyles: You're trying to set theme to: '" + std::string(themeName) + "', but it wasn't registered.");
+    }
 
     if (themeName != this->_currentThemeName) {
         this->_currentThemeName = themeName;
@@ -23,33 +25,33 @@ std::optional<std::string>& core::UnistylesState::getCurrentThemeName() {
     return this->_currentThemeName;
 }
 
-jsi::Object core::UnistylesState::getCurrentJSTheme() {
+jsi::Object core::UnistylesState::getCurrentJSTheme(jsi::Runtime& rt) {
     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.");
+        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);
+        return jsi::Object(rt);
     }
 
-    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?");
+    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(), "Unistyles: 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?");
 
-    return it->second.asObject(*_rt);
+    return it->second.asObject(rt);
 }
 
-jsi::Object core::UnistylesState::getJSThemeByName(std::string& themeName) {
+jsi::Object core::UnistylesState::getJSThemeByName(jsi::Runtime& rt, std::string& themeName) {
     auto it = this->_jsThemes.find(themeName);
 
-    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?");
+    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);
+    return it->second.asObject(rt);
 }
 
 void core::UnistylesState::computeCurrentBreakpoint(int screenWidth) {
@@ -99,28 +101,28 @@ void core::UnistylesState::registerParseBoxShadowString(jsi::Function&& fn) {
     this->_parseBoxShadowStringFn = std::make_shared<jsi::Function>(std::move(fn));
 }
 
-int core::UnistylesState::parseColor(jsi::Value& maybeColor) {
+int core::UnistylesState::parseColor(jsi::Runtime& rt, jsi::Value& maybeColor) {
     if (!maybeColor.isString()) {
         return 0;
     }
 
-    auto colorString = maybeColor.asString(*_rt);
+    auto colorString = maybeColor.asString(rt);
 
-    if (!this->_colorCache.contains(colorString.utf8(*_rt).c_str())) {
+    if (!this->_colorCache.contains(colorString.utf8(rt).c_str())) {
         #ifdef ANDROID
-            int color = this->_processColorFn.get()->call(*_rt, colorString).asNumber();
+            int color = this->_processColorFn.get()->call(rt, colorString).asNumber();
         #else
-            uint32_t color = this->_processColorFn.get()->call(*_rt, colorString).asNumber();
+            uint32_t color = this->_processColorFn.get()->call(rt, colorString).asNumber();
         #endif
 
-        this->_colorCache[colorString.utf8(*_rt).c_str()] = color ? color : 0;
+        this->_colorCache[colorString.utf8(rt).c_str()] = color ? color : 0;
     }
 
-    return this->_colorCache[colorString.utf8(*_rt).c_str()];
+    return this->_colorCache[colorString.utf8(rt).c_str()];
 }
 
-jsi::Array core::UnistylesState::parseBoxShadowString(std::string&& boxShadowString) {
-    jsi::Value result = this->_parseBoxShadowStringFn.get()->call(*_rt, boxShadowString);
+jsi::Array core::UnistylesState::parseBoxShadowString(jsi::Runtime& rt, std::string&& boxShadowString) {
+    jsi::Value result = this->_parseBoxShadowStringFn.get()->call(rt, boxShadowString);
 
-    return result.asObject(*_rt).asArray(*_rt);
+    return result.asObject(rt).asArray(rt);
 }

package/cxx/core/UnistylesState.h

@@ -13,7 +13,7 @@ struct UnistylesRegistry;
 using namespace facebook;
 
 struct UnistylesState {
-    UnistylesState(jsi::Runtime& rt): _rt{&rt} {}
+    UnistylesState() = default;
     UnistylesState(const UnistylesState&) = delete;
     UnistylesState(const UnistylesState&&) = delete;
 
@@ -29,16 +29,15 @@ struct UnistylesState {
     std::optional<std::string> getCurrentBreakpointName();
     std::vector<std::pair<std::string, double>> getSortedBreakpointPairs();
 
-    jsi::Object getCurrentJSTheme();
-    jsi::Object getJSThemeByName(std::string& themeName);
-    int parseColor(jsi::Value& color);
-    jsi::Array parseBoxShadowString(std::string&& boxShadowString);
+    jsi::Object getCurrentJSTheme(jsi::Runtime& rt);
+    jsi::Object getJSThemeByName(jsi::Runtime& rt, std::string& themeName);
+    int parseColor(jsi::Runtime& rt, jsi::Value& color);
+    jsi::Array parseBoxShadowString(jsi::Runtime& rt, std::string&& boxShadowString);
     void computeCurrentBreakpoint(int screenWidth);
     void registerProcessColorFunction(jsi::Function&& fn);
     void registerParseBoxShadowString(jsi::Function&& fn);
 
 private:
-    jsi::Runtime* _rt;
     std::unordered_map<std::string, jsi::Value> _jsThemes{};
     std::optional<bool> _prefersAdaptiveThemes = std::nullopt;
     std::optional<std::string> _initialThemeName = std::nullopt;

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -13,7 +13,7 @@ jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisVa
     auto& registry = core::UnistylesRegistry::get();
 
     // this is special case for Animated, and prevents appending same unistyles to node
-    registry.removeDuplicatedUnistyles(rt, &shadowNodeWrapper->getFamily(), unistyleWrappers);
+    registry.removeDuplicatedUnistyles(&shadowNodeWrapper->getFamily(), unistyleWrappers);
 
     if (unistyleWrappers.empty()) {
         return jsi::Value::undefined();
@@ -45,7 +45,7 @@ jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisVa
     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.");
+        helpers::assertThat(rt, registry.getState().hasTheme(themeName), "Unistyles: You're trying to use scoped theme '" + themeName + "' but it wasn't registered.");
     }
 
     auto parser = parser::Parser(this->_unistylesRuntime);
@@ -107,7 +107,18 @@ jsi::Value HybridShadowRegistry::unlink(jsi::Runtime &rt, const jsi::Value &this
 
     auto& registry = core::UnistylesRegistry::get();
 
-    registry.unlinkShadowNodeWithUnistyles(rt, &shadowNodeWrapper->getFamily());
+    registry.unlinkShadowNodeWithUnistyles(&shadowNodeWrapper->getFamily());
+
+    return jsi::Value::undefined();
+}
+
+jsi::Value HybridShadowRegistry::suspend(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    helpers::assertThat(rt, count == 1, "Unistyles: Invalid babel transform 'ShadowRegistry suspend' expected 1 argument.");
+
+    auto shadowNodeWrapper = getShadowNodeFromRef(rt, args[0]);
+    auto& registry = core::UnistylesRegistry::get();
+
+    registry.suspendShadowNode(&shadowNodeWrapper->getFamily());
 
     return jsi::Value::undefined();
 }

package/cxx/hybridObjects/HybridShadowRegistry.h

@@ -22,6 +22,10 @@ struct HybridShadowRegistry: public HybridUnistylesShadowRegistrySpec {
                             const jsi::Value& thisValue,
                             const jsi::Value* args,
                             size_t count);
+    jsi::Value suspend(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
     jsi::Value flush(jsi::Runtime& rt,
                             const jsi::Value& thisValue,
                             const jsi::Value* args,
@@ -41,6 +45,7 @@ struct HybridShadowRegistry: public HybridUnistylesShadowRegistrySpec {
         registerHybrids(this, [](Prototype& prototype) {
             prototype.registerRawHybridMethod("link", 2, &HybridShadowRegistry::link);
             prototype.registerRawHybridMethod("unlink", 1, &HybridShadowRegistry::unlink);
+            prototype.registerRawHybridMethod("suspend", 1, &HybridShadowRegistry::suspend);
             prototype.registerRawHybridMethod("flush", 0, &HybridShadowRegistry::flush);
             prototype.registerRawHybridMethod("setScopedTheme", 1, &HybridShadowRegistry::setScopedTheme);
             prototype.registerRawHybridMethod("getScopedTheme", 0, &HybridShadowRegistry::getScopedTheme);

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -61,7 +61,7 @@ jsi::Value HybridStyleSheet::configure(jsi::Runtime &rt, const jsi::Value &thisV
 
     verifyAndSelectTheme(rt);
 
-    auto& state = core::UnistylesRegistry::get().getState(rt);
+    auto& state = core::UnistylesRegistry::get().getState();
 
     state.hasUserConfig = true;
 
@@ -76,7 +76,7 @@ jsi::Value HybridStyleSheet::init(jsi::Runtime &rt, const jsi::Value &thisVal, c
     // create new state
     auto& registry = core::UnistylesRegistry::get();
 
-    registry.createState(rt);
+    registry.createState();
 
     loadExternalMethods(thisVal, rt);
 
@@ -95,7 +95,7 @@ void HybridStyleSheet::parseSettings(jsi::Runtime &rt, jsi::Object settings) {
         if (propertyName == "adaptiveThemes") {
             helpers::assertThat(rt, propertyValue.isBool(), "StyleSheet.configure's adaptiveThemes must be of boolean type.");
 
-            registry.setPrefersAdaptiveThemes(rt, propertyValue.asBool());
+            registry.setPrefersAdaptiveThemes(propertyValue.asBool());
 
             return;
         }
@@ -108,12 +108,12 @@ void HybridStyleSheet::parseSettings(jsi::Runtime &rt, jsi::Object settings) {
 
                 helpers::assertThat(rt, result.isString(), "StyleSheet.configure's initialTheme resolved from function is not a string. Please check your initialTheme function.");
 
-                return registry.setInitialThemeName(rt, result.asString(rt).utf8(rt));
+                return registry.setInitialThemeName(result.asString(rt).utf8(rt));
             }
 
             helpers::assertThat(rt, propertyValue.isString(), "StyleSheet.configure's initialTheme must be either a string or a function.");
 
-            registry.setInitialThemeName(rt, propertyValue.asString(rt).utf8(rt));
+            registry.setInitialThemeName(propertyValue.asString(rt).utf8(rt));
 
             return;
         }
@@ -147,9 +147,9 @@ void HybridStyleSheet::parseBreakpoints(jsi::Runtime &rt, jsi::Object breakpoint
     helpers::assertThat(rt, sortedBreakpoints.front().second == 0, "StyleSheet.configure's first breakpoint must start from 0.");
 
     auto& registry = core::UnistylesRegistry::get();
-    auto& state = registry.getState(rt);
+    auto& state = registry.getState();
 
-    registry.registerBreakpoints(rt, sortedBreakpoints);
+    registry.registerBreakpoints(sortedBreakpoints);
 
     auto rawWidth = this->_unistylesRuntime->getScreen().width;
     auto width = registry.shouldUsePointsForBreakpoints
@@ -170,7 +170,7 @@ void HybridStyleSheet::parseThemes(jsi::Runtime &rt, jsi::Object themes) {
 }
 
 void HybridStyleSheet::verifyAndSelectTheme(jsi::Runtime &rt) {
-    auto& state = core::UnistylesRegistry::get().getState(rt);
+    auto& state = core::UnistylesRegistry::get().getState();
 
     bool hasInitialTheme = state.hasInitialTheme();
     bool prefersAdaptiveThemes = state.getPrefersAdaptiveThemes();
@@ -217,7 +217,7 @@ void HybridStyleSheet::verifyAndSelectTheme(jsi::Runtime &rt) {
 }
 
 void HybridStyleSheet::setThemeFromColorScheme(jsi::Runtime& rt) {
-    auto& state = core::UnistylesRegistry::get().getState(rt);
+    auto& state = core::UnistylesRegistry::get().getState();
     auto colorScheme = static_cast<ColorScheme>(this->_unistylesRuntime->getColorScheme());
 
     switch (colorScheme) {
@@ -250,7 +250,7 @@ void HybridStyleSheet::loadExternalMethods(const jsi::Value& thisValue, jsi::Run
     auto processColorFn = maybeProcessColorFn.asObject(rt).asFunction(rt);
     auto parseBoxShadowStringFn = maybeParseBoxShadowStringFn.asObject(rt).asFunction(rt);
     auto& registry = core::UnistylesRegistry::get();
-    auto& state = registry.getState(rt);
+    auto& state = registry.getState();
 
     state.registerProcessColorFunction(std::move(processColorFn));
     state.registerParseBoxShadowString(std::move(parseBoxShadowStringFn));
@@ -262,32 +262,42 @@ void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependen
         return;
     }
 
-    auto& registry = core::UnistylesRegistry::get();
-    auto& rt = this->_unistylesRuntime->getRuntime();
-    auto parser = parser::Parser(this->_unistylesRuntime);
-    auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
+    auto weakSelf = weak_from_this();
 
-    if (dependencyMap.empty()) {
-        this->notifyJSListeners(dependencies);
-    }
+    this->_unistylesRuntime->runOnJSThread([weakSelf, dependencies](jsi::Runtime& rt) {
+        auto self = std::dynamic_pointer_cast<HybridStyleSheet>(weakSelf.lock());
 
-    // in a later step, we will rebuild only Unistyles with mounted StyleSheets
-    // however, user may have StyleSheets with components that haven't mounted yet
-    // we need to rebuild all dependent StyleSheets as well
-    auto dependentStyleSheets = registry.getStyleSheetsToRefresh(rt, dependencies);
+        if (!self) {
+            return;
+        }
 
-    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, std::nullopt);
+        auto& registry = core::UnistylesRegistry::get();
+        auto parser = parser::Parser(self->_unistylesRuntime);
+        auto unistyleDependencies = dependencies;
+        auto dependencyMap = registry.buildDependencyMap(unistyleDependencies);
 
-    // we need to stop here if there is nothing to update at the moment,
-    // but we need to compute dependentStyleSheets
-    if (dependencyMap.empty()) {
-        return;
-    }
+        if (dependencyMap.empty()) {
+            self->notifyJSListeners(unistyleDependencies);
+        }
+
+        // in a later step, we will rebuild only Unistyles with mounted StyleSheets
+        // however, user may have StyleSheets with components that haven't mounted yet
+        // we need to rebuild all dependent StyleSheets as well
+        auto dependentStyleSheets = registry.getStyleSheetsToRefresh(unistyleDependencies);
+
+        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, std::nullopt);
+
+        // we need to stop here if there is nothing to update at the moment,
+        // but we need to compute dependentStyleSheets
+        if (dependencyMap.empty()) {
+            return;
+        }
 
-    parser.rebuildShadowLeafUpdates(rt, dependencyMap);
+        parser.rebuildShadowLeafUpdates(rt, dependencyMap);
 
-    this->notifyJSListeners(dependencies);
-    shadow::ShadowTreeManager::updateShadowTree(rt);
+        self->notifyJSListeners(unistyleDependencies);
+        shadow::ShadowTreeManager::updateShadowTree(rt);
+    });
 }
 
 void HybridStyleSheet::onPlatformNativeDependenciesChange(std::vector<UnistyleDependency> dependencies, UnistylesNativeMiniRuntime miniRuntime) {
@@ -296,21 +306,29 @@ void HybridStyleSheet::onPlatformNativeDependenciesChange(std::vector<UnistyleDe
         return;
     }
 
-    this->_unistylesRuntime->runOnJSThread([this, dependencies, miniRuntime](jsi::Runtime& rt){
+    auto weakSelf = weak_from_this();
+
+    this->_unistylesRuntime->runOnJSThread([weakSelf, dependencies, miniRuntime](jsi::Runtime& rt){
+        auto self = std::dynamic_pointer_cast<HybridStyleSheet>(weakSelf.lock());
+
+        if (!self) {
+            return;
+        }
+
         auto& registry = core::UnistylesRegistry::get();
-        auto parser = parser::Parser(this->_unistylesRuntime);
+        auto parser = parser::Parser(self->_unistylesRuntime);
         auto unistyleDependencies = std::move(dependencies);
 
         // re-compute new breakpoint
         auto dimensionsIt = std::find(dependencies.begin(), dependencies.end(), UnistyleDependency::DIMENSIONS);
 
         if (dimensionsIt != dependencies.end()) {
-            auto rawWidth = this->_unistylesRuntime->getScreen().width;
+            auto rawWidth = self->_unistylesRuntime->getScreen().width;
             auto width = registry.shouldUsePointsForBreakpoints
-                ? rawWidth / this->_unistylesRuntime->getPixelRatio()
+                ? rawWidth / self->_unistylesRuntime->getPixelRatio()
                 : rawWidth;
 
-            registry.getState(rt).computeCurrentBreakpoint(width);
+            registry.getState().computeCurrentBreakpoint(width);
         }
 
         // check if color scheme changed and then if Unistyles state depend on it (adaptive themes)
@@ -318,19 +336,19 @@ void HybridStyleSheet::onPlatformNativeDependenciesChange(std::vector<UnistyleDe
         auto hasNewColorScheme = colorSchemeIt != dependencies.end();
 
         if (hasNewColorScheme) {
-            this->_unistylesRuntime->includeDependenciesForColorSchemeChange(unistyleDependencies);
+            self->_unistylesRuntime->includeDependenciesForColorSchemeChange(unistyleDependencies);
         }
 
-        auto dependencyMap = registry.buildDependencyMap(rt, unistyleDependencies);
+        auto dependencyMap = registry.buildDependencyMap(unistyleDependencies);
 
         if (dependencyMap.empty()) {
-            this->notifyJSListeners(unistyleDependencies);
+            self->notifyJSListeners(unistyleDependencies);
         }
 
         // in a later step, we will rebuild only Unistyles with mounted StyleSheets
         // however, user may have StyleSheets with components that haven't mounted yet
         // we need to rebuild all dependent StyleSheets as well
-        auto dependentStyleSheets = registry.getStyleSheetsToRefresh(rt, unistyleDependencies);
+        auto dependentStyleSheets = registry.getStyleSheetsToRefresh(unistyleDependencies);
 
         parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, miniRuntime);
 
@@ -342,7 +360,7 @@ void HybridStyleSheet::onPlatformNativeDependenciesChange(std::vector<UnistyleDe
 
         parser.rebuildShadowLeafUpdates(rt, dependencyMap);
 
-        this->notifyJSListeners(unistyleDependencies);
+        self->notifyJSListeners(unistyleDependencies);
         shadow::ShadowTreeManager::updateShadowTree(rt);
     });
 }
@@ -352,14 +370,22 @@ void HybridStyleSheet::onImeChange(UnistylesNativeMiniRuntime miniRuntime) {
         return;
     }
 
-    this->_unistylesRuntime->runOnJSThread([this, miniRuntime](jsi::Runtime& rt){
+    auto weakSelf = weak_from_this();
+
+    this->_unistylesRuntime->runOnJSThread([weakSelf, miniRuntime](jsi::Runtime& rt){
+        auto self = std::dynamic_pointer_cast<HybridStyleSheet>(weakSelf.lock());
+
+        if (!self) {
+            return;
+        }
+
         std::vector<UnistyleDependency> dependencies{UnistyleDependency::IME};
         auto& registry = core::UnistylesRegistry::get();
-        auto parser = parser::Parser(this->_unistylesRuntime);
-        auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
+        auto parser = parser::Parser(self->_unistylesRuntime);
+        auto dependencyMap = registry.buildDependencyMap(dependencies);
 
         if (dependencyMap.empty()) {
-            this->notifyJSListeners(dependencies);
+            self->notifyJSListeners(dependencies);
 
             return;
         }
@@ -371,7 +397,7 @@ void HybridStyleSheet::onImeChange(UnistylesNativeMiniRuntime miniRuntime) {
         parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, miniRuntime);
         parser.rebuildShadowLeafUpdates(rt, dependencyMap);
 
-        this->notifyJSListeners(dependencies);
+        self->notifyJSListeners(dependencies);
         shadow::ShadowTreeManager::updateShadowTree(rt);
     });
 }

package/cxx/hybridObjects/HybridUnistylesRuntime.cpp

@@ -3,6 +3,10 @@
 
 using namespace margelo::nitro::unistyles;
 
+core::UnistylesState& HybridUnistylesRuntime::getState() {
+    return core::UnistylesRegistry::get().getState();
+}
+
 ColorScheme HybridUnistylesRuntime::getColorScheme() {
     auto colorScheme = this->_nativePlatform->getColorScheme();
 
@@ -10,9 +14,7 @@ ColorScheme HybridUnistylesRuntime::getColorScheme() {
 }
 
 bool HybridUnistylesRuntime::getHasAdaptiveThemes() {
-    auto& state = core::UnistylesRegistry::get().getState(*_rt);
-
-    return state.hasAdaptiveThemes();
+    return this->getState().hasAdaptiveThemes();
 };
 
 Dimensions HybridUnistylesRuntime::getScreen() {
@@ -22,14 +24,12 @@ Dimensions HybridUnistylesRuntime::getScreen() {
 std::optional<std::string> HybridUnistylesRuntime::getThemeName() {
     auto& registry = core::UnistylesRegistry::get();
     auto maybeScopedTheme = registry.getScopedTheme();
-    
+
     if (maybeScopedTheme.has_value()) {
         return maybeScopedTheme.value();
     }
-    
-    auto& state = registry.getState(*_rt);
-    
-    return state.getCurrentThemeName();
+
+    return this->getState().getCurrentThemeName();
 };
 
 std::string HybridUnistylesRuntime::getContentSizeCategory() {
@@ -37,9 +37,7 @@ std::string HybridUnistylesRuntime::getContentSizeCategory() {
 };
 
 std::optional<std::string> HybridUnistylesRuntime::getBreakpoint() {
-    auto& state = core::UnistylesRegistry::get().getState(*_rt);
-
-    return state.getCurrentBreakpointName();
+    return this->getState().getCurrentBreakpointName();
 };
 
 bool HybridUnistylesRuntime::getRtl() {
@@ -73,8 +71,7 @@ double HybridUnistylesRuntime::getFontScale() {
 };
 
 std::unordered_map<std::string, double> HybridUnistylesRuntime::getBreakpoints() {
-    auto& state = core::UnistylesRegistry::get().getState(*_rt);
-    auto sortedBreakpointPairs = state.getSortedBreakpointPairs();
+    auto sortedBreakpointPairs = this->getState().getSortedBreakpointPairs();
     std::unordered_map<std::string, double> breakpoints{};
 
     std::for_each(sortedBreakpointPairs.begin(), sortedBreakpointPairs.end(), [&breakpoints](std::pair<std::string, double>& pair){
@@ -85,12 +82,13 @@ std::unordered_map<std::string, double> HybridUnistylesRuntime::getBreakpoints()
 }
 
 void HybridUnistylesRuntime::setTheme(const std::string &themeName) {
-    helpers::assertThat(*_rt, !this->getHasAdaptiveThemes(), "Unistyles: You're trying to set theme to: '" + themeName + "', but adaptiveThemes are enabled.");
+    if (this->getHasAdaptiveThemes()) {
+        throw std::runtime_error("Unistyles: You're trying to set theme to: '" + themeName + "', but adaptiveThemes are enabled.");
+    }
 
-    auto& state = core::UnistylesRegistry::get().getState(*_rt);
-    auto currentThemeName = state.getCurrentThemeName();
+    auto currentThemeName = this->getState().getCurrentThemeName();
 
-    state.setTheme(themeName);
+    this->getState().setTheme(themeName);
 
     if (currentThemeName.value() != themeName) {
         this->_onDependenciesChange({UnistyleDependency::THEME, UnistyleDependency::THEMENAME});
@@ -106,7 +104,7 @@ void HybridUnistylesRuntime::setAdaptiveThemes(bool isEnabled) {
 
     bool hadAdaptiveThemes = this->getHasAdaptiveThemes();
 
-    registry.setPrefersAdaptiveThemes(*_rt, isEnabled);
+    registry.setPrefersAdaptiveThemes(isEnabled);
 
     bool haveAdaptiveThemes = this->getHasAdaptiveThemes();
 
@@ -128,7 +126,6 @@ void HybridUnistylesRuntime::setAdaptiveThemes(bool isEnabled) {
 };
 
 void HybridUnistylesRuntime::calculateNewThemeAndDependencies(std::vector<UnistyleDependency>& changedDependencies) {
-    auto& state = core::UnistylesRegistry::get().getState(*_rt);
     auto colorScheme = this->getColorScheme();
     auto currentThemeName = this->getThemeName();
     auto nextTheme = colorScheme == ColorScheme::LIGHT
@@ -139,18 +136,18 @@ void HybridUnistylesRuntime::calculateNewThemeAndDependencies(std::vector<Unisty
         changedDependencies.push_back(UnistyleDependency::THEME);
         changedDependencies.push_back(UnistyleDependency::THEMENAME);
 
-        state.setTheme(nextTheme);
+        this->getState().setTheme(nextTheme);
     }
 }
 
 jsi::Value HybridUnistylesRuntime::getTheme(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
     helpers::assertThat(rt, count <= 1, "UnistylesRuntime.getTheme expected to be called with 0 or 1 argument.");
 
-    auto& state = core::UnistylesRegistry::get().getState(*_rt);
+    auto& state = this->getState();
 
     if (count == 1) {
         if (args[0].isUndefined()) {
-            return state.getCurrentJSTheme();
+            return state.getCurrentJSTheme(rt);
         }
 
         helpers::assertThat(rt, args[0].isString(), "UnistylesRuntime.getTheme expected to be called with string.");
@@ -159,10 +156,10 @@ jsi::Value HybridUnistylesRuntime::getTheme(jsi::Runtime &rt, const jsi::Value &
 
         helpers::assertThat(rt, state.hasTheme(themeName), "Unistyles: You're trying to get theme '" + themeName + "' but it wasn't registered.");
 
-        return state.getJSThemeByName(themeName);
+        return state.getJSThemeByName(rt, themeName);
     }
 
-    return state.getCurrentJSTheme();
+    return state.getCurrentJSTheme(rt);
 }
 
 jsi::Value HybridUnistylesRuntime::updateTheme(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
@@ -292,17 +289,10 @@ void HybridUnistylesRuntime::unregisterNativePlatformListeners() {
 }
 
 void HybridUnistylesRuntime::includeDependenciesForColorSchemeChange(std::vector<UnistyleDependency>& deps) {
-    auto& registry = core::UnistylesRegistry::get();
-    auto& state = registry.getState(*this->_rt);
-
     // ignore color scheme changes if user has no adaptive themes
-    if (!state.hasAdaptiveThemes()) {
+    if (!this->getState().hasAdaptiveThemes()) {
         return;
     }
 
     this->calculateNewThemeAndDependencies(deps);
 }
-
-jsi::Runtime& HybridUnistylesRuntime::getRuntime() {
-    return *this->_rt;
-}

package/cxx/hybridObjects/HybridUnistylesRuntime.h

@@ -13,8 +13,8 @@
 namespace margelo::nitro::unistyles {
 
 struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
-    HybridUnistylesRuntime(std::shared_ptr<HybridNativePlatformSpec> nativePlatform, jsi::Runtime& rt, std::function<void(std::function<void(jsi::Runtime&)>&&)> runOnJSThread)
-        : HybridObject(TAG), _nativePlatform{nativePlatform}, _rt{&rt}, runOnJSThread(std::move(runOnJSThread)) {}
+    HybridUnistylesRuntime(std::shared_ptr<HybridNativePlatformSpec> nativePlatform, std::function<void(std::function<void(jsi::Runtime&)>&&)> runOnJSThread)
+        : HybridObject(TAG), _nativePlatform{nativePlatform}, runOnJSThread(std::move(runOnJSThread)) {}
 
     jsi::Value getTheme(jsi::Runtime& rt,
                             const jsi::Value& thisValue,
@@ -69,7 +69,7 @@ struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
     UnistylesCxxMiniRuntime getMiniRuntime() override;
     std::unordered_map<std::string, double> getBreakpoints() override;
 
-    jsi::Runtime& getRuntime();
+    core::UnistylesState& getState();
     UnistylesCxxMiniRuntime buildMiniRuntimeFromNativeRuntime(UnistylesNativeMiniRuntime& nativeMiniRuntime);
     jsi::Value getMiniRuntimeAsValue(jsi::Runtime& rt, std::optional<UnistylesNativeMiniRuntime> maybeMiniRuntime);
     void includeDependenciesForColorSchemeChange(std::vector<UnistyleDependency>& deps);
@@ -77,7 +77,6 @@ struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
     std::function<void(std::function<void(jsi::Runtime&)>&&)> runOnJSThread;
 
 private:
-    jsi::Runtime* _rt;
     std::shared_ptr<HybridNavigationBar> _navigationBar;
     std::shared_ptr<HybridStatusBar> _statusBar;
     std::shared_ptr<HybridNativePlatformSpec> _nativePlatform;