react-native-unistyles 3.1.1 → 3.2.1

package/README.md

@@ -24,10 +24,11 @@ Install dependencies:
 yarn add react-native-nitro-modules
 ```
 
-| react-native-unistyles | Minimum react-native-nitro-modules |
-|------------------------|-------------------------------------|
+| react-native-unistyles | Minimum react-native-nitro-modules     |
+|------------------------|----------------------------------------|
 | >= 3.0.0               | >= 0.33.9                              |
 | >= 3.1.0               | >= 0.35.0                              |
+| >= 3.2.0               | >= 0.35.2                              |
 
 > **Note:** Since v3.1.0, `react-native-edge-to-edge` is an **optional** dependency. We strongly recommend setting `edgeToEdgeEnabled=true` in your `android/gradle.properties` — it enforces translucent system bars on modals, disables legacy StatusBar hacks, and enables additional React Native core fixes. **Expo SDK 54+** enables this automatically. You can still install `react-native-edge-to-edge` for ecosystem compatibility with libraries like `react-native-bootsplash` or `react-native-permissions`.
 

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

@@ -33,11 +33,8 @@ void UnistylesModule::registerNatives() {
 jni::local_ref<BindingsInstallerHolder::javaobject> UnistylesModule::getBindingsInstaller(jni::alias_ref<UnistylesModule::javaobject> jobj) {
     auto& runtimeExecutor = jobj->cthis()->_runtimeExecutor;
     auto& nativePlatform = jobj->cthis()->_nativePlatform;
-    auto* self = jobj->cthis();
-
-    return BindingsInstallerHolder::newObjectCxxArgs([&runtimeExecutor, &nativePlatform, self](jsi::Runtime& rt) {
-        self->_runtime = &rt;
 
+    return BindingsInstallerHolder::newObjectCxxArgs([&runtimeExecutor, &nativePlatform](jsi::Runtime& rt) {
         // function is called on: first init and every live reload
         // check if this is live reload, if so let's replace UnistylesRuntime with new runtime
         auto hasUnistylesRuntime = HybridObjectRegistry::hasHybridObject("UnistylesRuntime");
@@ -55,7 +52,7 @@ jni::local_ref<BindingsInstallerHolder::javaobject> UnistylesModule::getBindings
         };
 
         // init hybrids
-        auto unistylesRuntime = std::make_shared<HybridUnistylesRuntime>(nativePlatform, rt, runOnJSThread);
+        auto unistylesRuntime = std::make_shared<HybridUnistylesRuntime>(nativePlatform, runOnJSThread);
         auto styleSheet = std::make_shared<HybridStyleSheet>(unistylesRuntime);
 
         HybridObjectRegistry::registerHybridObjectConstructor("UnistylesRuntime", [unistylesRuntime]() -> std::shared_ptr<HybridObject>{

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

@@ -29,12 +29,7 @@ struct UnistylesModule : public jni::HybridClass<UnistylesModule> {
         jni::alias_ref<JHybridNativePlatformSpec::JavaPart> nativePlatform
     );
     static void invalidateNative(jni::alias_ref<jhybridobject> jThis) {
-        auto* self = jThis->cthis();
-
-        if (self->_runtime) {
-            core::UnistylesRegistry::get().destroyState(self->_runtime);
-            self->_runtime = nullptr;
-        }
+        core::UnistylesRegistry::get().destroy();
     }
 
     static jni::local_ref<BindingsInstallerHolder::javaobject> getBindingsInstaller(jni::alias_ref<UnistylesModule::javaobject> jThis);
@@ -42,7 +37,6 @@ struct UnistylesModule : public jni::HybridClass<UnistylesModule> {
 private:
     RuntimeExecutor _runtimeExecutor;
     std::shared_ptr<HybridNativePlatformSpec> _nativePlatform;
-    jsi::Runtime* _runtime = nullptr;
 };
 
 }

package/android/src/main/java/com/unistyles/Equatable.kt

@@ -54,7 +54,11 @@ fun NativePlatformAndroid.diffMiniRuntimes(lhs: UnistylesNativeMiniRuntime, rhs:
         dependencies.add(UnistyleDependency.NAVIGATIONBAR)
     }
 
-    // rtl and pixel ratio are not dynamic
+    if (lhs.rtl != rhs.rtl) {
+        dependencies.add(UnistyleDependency.RTL)
+    }
+
+    // pixel ratio is not dynamic
 
     return dependencies.toTypedArray()
 }

package/android/src/main/java/com/unistyles/NativePlatform+android.kt

@@ -37,6 +37,8 @@ class NativePlatformAndroid(private val reactContext: ReactApplicationContext):
     }
 
     fun onDestroy() {
+        _listener.onDestroy()
+        _insets.onDestroy()
         reactContext.removeLifecycleEventListener(this)
     }
 
@@ -155,11 +157,14 @@ class NativePlatformAndroid(private val reactContext: ReactApplicationContext):
             "com.facebook.react.modules.i18nmanager.I18nUtil",
             Context.MODE_PRIVATE
         )
+        val resourcesLocale = reactContext.resources.configuration.locales[0]
         val hasForcedRtl = sharedPrefs.getBoolean("RCTI18nUtil_forceRTL", false)
         // user preferences
         val isRtl = TextUtilsCompat.getLayoutDirectionFromLocale(Locale.getDefault()) == ViewCompat.LAYOUT_DIRECTION_RTL
+        val isResourcesRtl = TextUtilsCompat.getLayoutDirectionFromLocale(resourcesLocale) == ViewCompat.LAYOUT_DIRECTION_RTL
 
-        return hasForcedRtl || isRtl
+
+        return hasForcedRtl || isRtl || isResourcesRtl
     }
 
     override fun setRootViewBackgroundColor(color: Double) {

package/android/src/main/java/com/unistyles/NativePlatform+listener.kt

@@ -4,6 +4,7 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
+import android.content.SharedPreferences
 import android.os.Handler
 import android.os.Looper
 import androidx.annotation.Keep
@@ -23,21 +24,38 @@ class NativePlatformListener(
 ) {
     private val _dependencyListeners: MutableList<CxxDependencyListener> = mutableListOf()
 
+    private fun notifyConfigChangedWithDelay() {
+        Handler(Looper.getMainLooper()).postDelayed({
+            this@NativePlatformListener.onConfigChange()
+        }, 25)
+    }
+
     private val configurationChangeReceiver = object : BroadcastReceiver() {
         override fun onReceive(context: Context, intent: Intent) {
-            Handler(Looper.getMainLooper()).postDelayed({
-                this@NativePlatformListener.onConfigChange()
-            }, 25)
+            notifyConfigChangedWithDelay()
+        }
+    }
+
+    private val rtlPreferenceListener = SharedPreferences.OnSharedPreferenceChangeListener { prefs, key ->
+        if (key == "RCTI18nUtil_forceRTL") {
+            notifyConfigChangedWithDelay()
         }
     }
 
+    private val i18nUtilSharedPrefs = reactContext.getSharedPreferences(
+        "com.facebook.react.modules.i18nmanager.I18nUtil",
+        Context.MODE_PRIVATE
+    )
+
     init {
         reactContext.registerReceiver(configurationChangeReceiver, IntentFilter(Intent.ACTION_CONFIGURATION_CHANGED))
+        i18nUtilSharedPrefs.registerOnSharedPreferenceChangeListener(rtlPreferenceListener)
     }
 
     fun onDestroy() {
         this.removePlatformListeners()
         reactContext.unregisterReceiver(configurationChangeReceiver)
+        i18nUtilSharedPrefs.unregisterOnSharedPreferenceChangeListener(rtlPreferenceListener)
     }
 
     fun addPlatformListener(listener: CxxDependencyListener) {

package/cxx/core/UnistyleWrapper.h

@@ -57,7 +57,7 @@ inline static std::vector<Unistyle::Shared> unistylesFromHashKeys(jsi::Runtime&
     auto& registry = UnistylesRegistry::get();
 
     for (auto& key: keys) {
-        unistyles.emplace_back(registry.getUnistyleById(rt, key));
+        unistyles.emplace_back(registry.getUnistyleById(key));
     }
 
     return unistyles;
@@ -157,7 +157,7 @@ inline static jsi::Value objectFromUnistyle(jsi::Runtime& rt, std::shared_ptr<Hy
         [unistyleID = unistyle->unid, unistylesRuntime, variants, parsedArguments](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count
     ) {
         auto& registry = UnistylesRegistry::get();
-        auto unistyle = registry.getUnistyleById(rt, unistyleID);
+        auto unistyle = registry.getUnistyleById(unistyleID);
 
         parser::Parser(unistylesRuntime).rebuildUnistyle(rt, unistyle, variants, parsedArguments);
 

package/cxx/core/UnistylesRegistry.cpp

@@ -9,50 +9,44 @@ using namespace facebook::react;
 std::atomic<int> core::UnistylesRegistry::_nextStyleSheetTag{0};
 
 void core::UnistylesRegistry::registerTheme(jsi::Runtime& rt, std::string name, jsi::Value& theme) {
-    auto& state = this->getState(rt);
+    auto& state = this->getState();
 
     state._jsThemes.emplace(name, std::move(theme));
     state._registeredThemeNames.push_back(name);
 }
 
-void core::UnistylesRegistry::registerBreakpoints(jsi::Runtime& rt, std::vector<std::pair<std::string, double>>& sortedBreakpoints) {
-    auto& state = this->getState(rt);
+void core::UnistylesRegistry::registerBreakpoints(std::vector<std::pair<std::string, double>>& sortedBreakpoints) {
+    auto& state = this->getState();
 
     state._sortedBreakpointPairs = std::move(sortedBreakpoints);
 }
 
-void core::UnistylesRegistry::setPrefersAdaptiveThemes(jsi::Runtime& rt, bool prefersAdaptiveThemes) {
-    auto& state = this->getState(rt);
+void core::UnistylesRegistry::setPrefersAdaptiveThemes(bool prefersAdaptiveThemes) {
+    auto& state = this->getState();
 
     state._prefersAdaptiveThemes = prefersAdaptiveThemes;
 }
 
-void core::UnistylesRegistry::setInitialThemeName(jsi::Runtime& rt, std::string themeName) {
-    auto& state = this->getState(rt);
+void core::UnistylesRegistry::setInitialThemeName(std::string themeName) {
+    auto& state = this->getState();
 
     state._initialThemeName = themeName;
 }
 
-core::UnistylesState& core::UnistylesRegistry::getState(jsi::Runtime& rt) {
-    auto it = this->_states.find(&rt);
-
-    helpers::assertThat(rt, it != this->_states.end(), "Unistyles was loaded, but it's not configured. Did you forget to call StyleSheet.configure? If you don't want to use any themes or breakpoints, simply call it with an empty object {}.");
+core::UnistylesState& core::UnistylesRegistry::getState() {
+    if (!this->_state) {
+        throw std::runtime_error("Unistyles was loaded, but it's not configured. Did you forget to call StyleSheet.configure? If you don't want to use any themes or breakpoints, simply call it with an empty object {}.");
+    }
 
-    return it->second;
+    return *this->_state;
 }
 
-void core::UnistylesRegistry::createState(jsi::Runtime& rt) {
-    auto it = this->_states.find(&rt);
-
-    this->_states.emplace(
-        std::piecewise_construct,
-        std::forward_as_tuple(&rt),
-        std::forward_as_tuple(rt)
-    );
+void core::UnistylesRegistry::createState() {
+    this->_state = std::make_unique<UnistylesState>();
 }
 
 void core::UnistylesRegistry::updateTheme(jsi::Runtime& rt, std::string& themeName, jsi::Function&& callback) {
-    auto& state = this->getState(rt);
+    auto& state = this->getState();
     auto it = state._jsThemes.find(themeName);
 
     helpers::assertThat(rt, it != state._jsThemes.end(), "Unistyles: You're trying to update theme '" + themeName + "' but it wasn't registered.");
@@ -70,22 +64,36 @@ void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
     std::vector<std::shared_ptr<UnistyleData>>& unistylesData
 ) {
     this->trafficController.withLock([this, &rt, &unistylesData, shadowNodeFamily](){
+        // Clear suspension state if this family was previously suspended
+        if (_suspendedFamilies.erase(shadowNodeFamily) > 0) {
+            auto* mutableFamily = const_cast<ShadowNodeFamily*>(shadowNodeFamily);
+            mutableFamily->nativeProps_DEPRECATED.reset();
+        }
+
         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);
+        std::for_each(unistylesData.begin(), unistylesData.end(), [this, shadowNodeFamily](std::shared_ptr<UnistyleData> unistyleData){
+            this->_shadowRegistry[shadowNodeFamily].emplace_back(unistyleData);
         });
 
         updates[shadowNodeFamily] = parser.parseStylesToShadowTreeStyles(rt, unistylesData);
 
+        auto* mutableFamily = const_cast<ShadowNodeFamily*>(shadowNodeFamily);
+
+        if (mutableFamily->nativeProps_DEPRECATED) {
+            mutableFamily->nativeProps_DEPRECATED->update(updates[shadowNodeFamily]);
+        } else {
+            mutableFamily->nativeProps_DEPRECATED = std::make_unique<folly::dynamic>(updates[shadowNodeFamily]);
+        }
+
         this->trafficController.setUpdates(updates);
         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];
+void core::UnistylesRegistry::removeDuplicatedUnistyles(const ShadowNodeFamily *shadowNodeFamily, std::vector<core::Unistyle::Shared>& unistyles) {
+    auto targetFamilyUnistyles = this->_shadowRegistry[shadowNodeFamily];
 
     unistyles.erase(
         std::remove_if(
@@ -105,32 +113,41 @@ void core::UnistylesRegistry::removeDuplicatedUnistyles(jsi::Runtime& rt, const
     );
 }
 
-void core::UnistylesRegistry::unlinkShadowNodeWithUnistyles(jsi::Runtime& rt, const ShadowNodeFamily* shadowNodeFamily) {
-    this->trafficController.withLock([this, &rt, shadowNodeFamily](){
-        this->_shadowRegistry[&rt].erase(shadowNodeFamily);
+void core::UnistylesRegistry::unlinkShadowNodeWithUnistyles(const ShadowNodeFamily* shadowNodeFamily) {
+    this->trafficController.withLock([this, shadowNodeFamily](){
+        this->_shadowRegistry.erase(shadowNodeFamily);
+        this->_suspendedFamilies.erase(shadowNodeFamily);
         this->trafficController.removeShadowNode(shadowNodeFamily);
+    });
+}
 
-        if (this->_shadowRegistry[&rt].empty()) {
-            this->_shadowRegistry.erase(&rt);
+void core::UnistylesRegistry::suspendShadowNode(const ShadowNodeFamily* shadowNodeFamily) {
+    this->trafficController.withLock([this, shadowNodeFamily](){
+        if (this->_shadowRegistry.contains(shadowNodeFamily)) {
+            this->_suspendedFamilies.insert(shadowNodeFamily);
         }
     });
 }
 
+bool core::UnistylesRegistry::isSuspended(const ShadowNodeFamily* family) const noexcept {
+    return _suspendedFamilies.count(family) > 0;
+}
+
 std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::addStyleSheet(jsi::Runtime& rt, core::StyleSheetType type, jsi::Object&& rawValue) {
     int tag = _nextStyleSheetTag.fetch_add(1);
 
     auto sheet = std::make_shared<core::StyleSheet>(tag, type, std::move(rawValue));
-    this->_styleSheetRegistry[&rt][tag] = sheet;
+    this->_styleSheetRegistry[tag] = sheet;
 
     return sheet;
 }
 
-core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt, std::vector<UnistyleDependency>& deps) {
+core::DependencyMap core::UnistylesRegistry::buildDependencyMap(std::vector<UnistyleDependency>& deps) {
     core::DependencyMap dependencyMap;
 
     std::unordered_set<UnistyleDependency> uniqueDependencies(deps.begin(), deps.end());
 
-    for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+    for (const auto& [family, unistyles] : this->_shadowRegistry) {
         bool hasAnyOfDependencies = false;
 
         // Check if any dependency matches
@@ -171,7 +188,7 @@ void core::UnistylesRegistry::shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Uni
             ? std::make_optional(maybePressableId.asString(rt).utf8(rt))
             : std::nullopt;
 
-        for (const auto& [family, unistyles] : this->_shadowRegistry[&rt]) {
+        for (const auto& [family, unistyles] : this->_shadowRegistry) {
             for (const auto& unistyleData : unistyles) {
                 if (unistyleData->unistyle == unistyle) {
                     updates[family] = parser.parseStylesToShadowTreeStyles(rt, { unistyleData });
@@ -183,7 +200,7 @@ void core::UnistylesRegistry::shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Uni
     });
 }
 
-std::vector<std::shared_ptr<core::StyleSheet>>core::UnistylesRegistry::getStyleSheetsToRefresh(jsi::Runtime& rt, std::vector<UnistyleDependency>& unistylesDependencies) {
+std::vector<std::shared_ptr<core::StyleSheet>>core::UnistylesRegistry::getStyleSheetsToRefresh(std::vector<UnistyleDependency>& unistylesDependencies) {
     std::vector<std::shared_ptr<core::StyleSheet>> stylesheetsToRefresh;
     std::unordered_set<UnistyleDependency> depSet(
         unistylesDependencies.begin(),
@@ -197,8 +214,6 @@ std::vector<std::shared_ptr<core::StyleSheet>>core::UnistylesRegistry::getStyleS
         return stylesheetsToRefresh;
     }
 
-    auto& styleSheets = this->_styleSheetRegistry[&rt];
-
     auto hasMatchingDependency = [&depSet](const auto& unistyles) {
         for (const auto& [_, unistyle] : unistyles) {
             for (const auto& dep : unistyle->dependencies) {
@@ -211,7 +226,7 @@ std::vector<std::shared_ptr<core::StyleSheet>>core::UnistylesRegistry::getStyleS
         return false;
     };
 
-    for (const auto& [_, styleSheet] : styleSheets) {
+    for (const auto& [_, styleSheet] : this->_styleSheetRegistry) {
         if (styleSheet->type == StyleSheetType::ThemableWithMiniRuntime || styleSheet->type == StyleSheetType::Static) {
             if (hasMatchingDependency(styleSheet->unistyles)) {
                 stylesheetsToRefresh.emplace_back(styleSheet);
@@ -226,8 +241,8 @@ std::vector<std::shared_ptr<core::StyleSheet>>core::UnistylesRegistry::getStyleS
     return stylesheetsToRefresh;
 }
 
-core::Unistyle::Shared core::UnistylesRegistry::getUnistyleById(jsi::Runtime& rt, std::string unistyleID) {
-    for (auto& pair: this->_styleSheetRegistry[&rt]) {
+core::Unistyle::Shared core::UnistylesRegistry::getUnistyleById(std::string unistyleID) {
+    for (auto& pair: this->_styleSheetRegistry) {
         auto [_, stylesheet] = pair;
 
         for (auto unistylePair: stylesheet->unistyles) {
@@ -251,16 +266,10 @@ void core::UnistylesRegistry::setScopedTheme(std::optional<std::string> themeNam
 }
 
 void core::UnistylesRegistry::destroy() {
-    this->_states.clear();
+    this->_state.reset();
     this->_styleSheetRegistry.clear();
     this->_shadowRegistry.clear();
+    this->_suspendedFamilies.clear();
     this->_scopedTheme = std::nullopt;
     _nextStyleSheetTag.store(0);
 }
-
-void core::UnistylesRegistry::destroyState(jsi::Runtime* rt) {
-    this->_states.erase(rt);
-    this->_styleSheetRegistry.erase(rt);
-    this->_shadowRegistry.erase(rt);
-    this->_scopedTheme = std::nullopt;
-}

package/cxx/core/UnistylesRegistry.h

@@ -32,35 +32,37 @@ struct UnistylesRegistry: public StyleSheetRegistry {
     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);
-    void setPrefersAdaptiveThemes(jsi::Runtime& rt, bool prefersAdaptiveThemes);
-    void setInitialThemeName(jsi::Runtime& rt, std::string themeName);
+    void registerBreakpoints(std::vector<std::pair<std::string, double>>& sortedBreakpoints);
+    void setPrefersAdaptiveThemes(bool prefersAdaptiveThemes);
+    void setInitialThemeName(std::string themeName);
     void updateTheme(jsi::Runtime& rt, std::string& themeName, jsi::Function&& callback);
 
-    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);
+    UnistylesState& getState();
+    void createState();
+    std::vector<std::shared_ptr<core::StyleSheet>> getStyleSheetsToRefresh(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*);
+    void unlinkShadowNodeWithUnistyles(const ShadowNodeFamily*);
+    void suspendShadowNode(const ShadowNodeFamily*);
+    bool isSuspended(const ShadowNodeFamily*) const noexcept;
     std::shared_ptr<core::StyleSheet> addStyleSheet(jsi::Runtime& rt, core::StyleSheetType type, jsi::Object&& rawValue);
-    DependencyMap buildDependencyMap(jsi::Runtime& rt, std::vector<UnistyleDependency>& deps);
+    DependencyMap buildDependencyMap(std::vector<UnistyleDependency>& deps);
     void shadowLeafUpdateFromUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle, jsi::Value& maybePressableId);
     shadow::ShadowTrafficController trafficController{};
     const std::optional<std::string> getScopedTheme();
-    void removeDuplicatedUnistyles(jsi::Runtime& rt, const ShadowNodeFamily* shadowNodeFamily, std::vector<core::Unistyle::Shared>& unistyles);
+    void removeDuplicatedUnistyles(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);
+    core::Unistyle::Shared getUnistyleById(std::string unistyleID);
     void destroy();
-    void destroyState(jsi::Runtime* rt);
 
 private:
     UnistylesRegistry() = default;
 
     static std::atomic<int> _nextStyleSheetTag;
     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<std::shared_ptr<UnistyleData>>>> _shadowRegistry{};
+    std::unique_ptr<UnistylesState> _state{};
+    std::unordered_map<int, std::shared_ptr<core::StyleSheet>> _styleSheetRegistry{};
+    std::unordered_map<const ShadowNodeFamily*, std::vector<std::shared_ptr<UnistyleData>>> _shadowRegistry{};
+    std::unordered_set<const ShadowNodeFamily*> _suspendedFamilies{};
 };
 
 inline UnistylesRegistry& UnistylesRegistry::get() {

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