react-native-unistyles 3.0.0-alpha.3 → 3.0.0-alpha.31

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -9,28 +9,25 @@ double HybridStyleSheet::getHairlineWidth() {
     return nearestPixel / pixelRatio;
 }
 
-double HybridStyleSheet::get___unid() {
+double HybridStyleSheet::getUnid() {
     return this->__unid;
 }
 
-jsi::Value HybridStyleSheet::create(jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) {
-    helpers::assertThat(rt, count == 1, "StyleSheet.create expected to be called with one argument.");
+jsi::Value HybridStyleSheet::create(jsi::Runtime& rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) {
+    if (count == 1) {
+        helpers::assertThat(rt, count == 2, "Unistyles is not initialized correctly. Please add babel plugin to your babel config.");
+    }
+
+    // second argument is hidden, so validation is perfectly fine
+    helpers::assertThat(rt, count == 2, "StyleSheet.create expected to be called with one argument.");
     helpers::assertThat(rt, arguments[0].isObject(), "StyleSheet.create expected to be called with object or function.");
 
     auto thisStyleSheet = thisVal.asObject(rt);
     auto& registry = core::UnistylesRegistry::get();
-
-    // this might happen only when hot reloading
-    if (this->__unid != -1) {
-        auto registeredStyleSheet = registry.getStyleSheetById(this->__unid);
-        auto style = std::make_shared<core::HostStyle>(registeredStyleSheet, this->_unistylesRuntime);
-        auto styleHostObject = jsi::Object::createFromHostObject(rt, style);
-
-        return styleHostObject;
-    }
+    int unid = arguments[1].asNumber();
 
     jsi::Object rawStyleSheet = arguments[0].asObject(rt);
-    auto registeredStyleSheet = registry.addStyleSheetFromValue(rt, std::move(rawStyleSheet));
+    auto registeredStyleSheet = registry.addStyleSheetFromValue(rt, std::move(rawStyleSheet), unid);
 
     this->__unid = registeredStyleSheet->tag;
 
@@ -49,36 +46,47 @@ jsi::Value HybridStyleSheet::configure(jsi::Runtime &rt, const jsi::Value &thisV
     helpers::assertThat(rt, count == 1, "StyleSheet.configure expected to be called with one argument.");
     helpers::assertThat(rt, arguments[0].isObject(), "StyleSheet.configure expected to be called with object.");
 
-    // create new state
     auto config = arguments[0].asObject(rt);
-    auto& registry = core::UnistylesRegistry::get();
-
-    registry.createState(rt);
 
     helpers::enumerateJSIObject(rt, config, [&](const std::string& propertyName, jsi::Value& propertyValue){
         if (propertyName == "settings") {
-            helpers::assertThat(rt, propertyValue.isObject(), "settings must be an object.");
+            helpers::assertThat(rt, propertyValue.isObject(), "StyleSheet.configure's settings must be an object.");
 
             return this->parseSettings(rt, propertyValue.asObject(rt));
         }
 
         if (propertyName == "breakpoints") {
-            helpers::assertThat(rt, propertyValue.isObject(), "breakpoints must be an object.");
+            helpers::assertThat(rt, propertyValue.isObject(), "StyleSheet.configure's breakpoints must be an object.");
 
             return this->parseBreakpoints(rt, propertyValue.asObject(rt));
         }
 
         if (propertyName == "themes") {
-            helpers::assertThat(rt, propertyValue.isObject(), "themes must be an object.");
+            helpers::assertThat(rt, propertyValue.isObject(), "StyleSheet.configure's themes must be an object.");
 
             return this->parseThemes(rt, propertyValue.asObject(rt));
         }
 
-        helpers::assertThat(rt, false, "received unexpected key: '" + std::string(propertyName) + "'.");
+        helpers::assertThat(rt, false, "StyleSheet.configure received unexpected key: '" + std::string(propertyName) + "'.");
     });
 
     verifyAndSelectTheme(rt);
+
+    auto& state = core::UnistylesRegistry::get().getState(rt);
+
+    state.hasUserConfig = true;
+
+    return jsi::Value::undefined();
+}
+
+jsi::Value HybridStyleSheet::init(jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) {
+    // create new state
+    auto& registry = core::UnistylesRegistry::get();
+
+    registry.createState(rt);
+
     loadExternalMethods(thisVal, rt);
+    registerHooks(rt);
 
     return jsi::Value::undefined();
 }
@@ -88,7 +96,7 @@ void HybridStyleSheet::parseSettings(jsi::Runtime &rt, jsi::Object settings) {
 
     helpers::enumerateJSIObject(rt, settings, [&](const std::string& propertyName, jsi::Value& propertyValue){
         if (propertyName == "adaptiveThemes") {
-            helpers::assertThat(rt, propertyValue.isBool(), "adaptiveThemes configuration must be of boolean type.");
+            helpers::assertThat(rt, propertyValue.isBool(), "StyleSheet.configure's adaptiveThemes must be of boolean type.");
 
             registry.setPrefersAdaptiveThemes(rt, propertyValue.asBool());
 
@@ -97,31 +105,31 @@ void HybridStyleSheet::parseSettings(jsi::Runtime &rt, jsi::Object settings) {
 
         if (propertyName == "initialTheme") {
             if (propertyValue.isObject()) {
-                helpers::assertThat(rt, propertyValue.asObject(rt).isFunction(rt), "initialTheme configuration must be either a string or a function.");
+                helpers::assertThat(rt, propertyValue.asObject(rt).isFunction(rt), "StyleSheet.configure's initialTheme must be either a string or a function.");
 
                 auto result = propertyValue.asObject(rt).asFunction(rt).call(rt);
 
-                helpers::assertThat(rt, result.isString(), "initialTheme resolved from function is not a string. Please check your initialTheme function.");
+                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));
             }
 
-            helpers::assertThat(rt, propertyValue.isString(), "initialTheme configuration must be either a string or a function.");
+            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));
 
             return;
         }
 
-        helpers::assertThat(rt, false, "settings received unexpected key: '" + std::string(propertyName) + "'");
+        helpers::assertThat(rt, false, "StyleSheet.configure's settings received unexpected key: '" + std::string(propertyName) + "'");
     });
 }
 
 void HybridStyleSheet::parseBreakpoints(jsi::Runtime &rt, jsi::Object breakpoints){
     helpers::Breakpoints sortedBreakpoints = helpers::jsiBreakpointsToVecPairs(rt, std::move(breakpoints));
 
-    helpers::assertThat(rt, sortedBreakpoints.size() > 0, "registered breakpoints can't be empty.");
-    helpers::assertThat(rt, sortedBreakpoints.front().second == 0, "first breakpoint must start from 0.");
+    helpers::assertThat(rt, sortedBreakpoints.size() > 0, "StyleSheet.configure's breakpoints can't be empty.");
+    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);
@@ -134,13 +142,12 @@ void HybridStyleSheet::parseThemes(jsi::Runtime &rt, jsi::Object themes) {
     auto& registry = core::UnistylesRegistry::get();
 
     helpers::enumerateJSIObject(rt, themes, [&](const std::string& propertyName, jsi::Value& propertyValue){
-        helpers::assertThat(rt, propertyValue.isObject(), "registered theme '" + propertyName + "' must be an object.");
+        helpers::assertThat(rt, propertyValue.isObject(), "StyleSheet.configure's registered theme '" + propertyName + "' must be an object.");
 
-        registry.registerTheme(rt, propertyName, propertyValue.asObject(rt));
+        registry.registerTheme(rt, propertyName, propertyValue);
     });
 }
 
-
 void HybridStyleSheet::verifyAndSelectTheme(jsi::Runtime &rt) {
     auto& state = core::UnistylesRegistry::get().getState(rt);
 
@@ -152,7 +159,7 @@ void HybridStyleSheet::verifyAndSelectTheme(jsi::Runtime &rt) {
 
     // user tries to enable adaptive themes, but didn't register both 'light' and 'dark' themes
     if (prefersAdaptiveThemes && !hasAdaptiveThemes) {
-        helpers::assertThat(rt, false, "you're trying to enable adaptiveThemes, but you didn't register both 'light' and 'dark' themes.");
+        helpers::assertThat(rt, false, "Unistyles: You're trying to enable adaptiveThemes, but you didn't register both 'light' and 'dark' themes.");
     }
 
     // user didn't select initial theme nor can have adaptive themes, and registered more than 1 theme
@@ -176,14 +183,14 @@ void HybridStyleSheet::verifyAndSelectTheme(jsi::Runtime &rt) {
     // user selected both initial theme and adaptive themes
     // we should throw an error as these options are mutually exclusive
     if (hasInitialTheme && hasAdaptiveThemes) {
-        helpers::assertThat(rt, false, "you're trying to set initial theme and enable adaptiveThemes, but these options are mutually exclusive.");
+        helpers::assertThat(rt, false, "Unistyles: You're trying to set initial theme and enable adaptiveThemes, but these options are mutually exclusive.");
     }
 
     // user only selected initial theme
     // validate if following theme exist
     std::string selectedTheme = state.getInitialTheme().value();
 
-    helpers::assertThat(rt, state.hasTheme(selectedTheme), "you're trying to select theme '" + selectedTheme + "' but it wasn't registered.");
+    helpers::assertThat(rt, state.hasTheme(selectedTheme), "Unistyles: You're trying to select theme '" + selectedTheme + "' but it wasn't registered.");
 
     state.setTheme(selectedTheme);
 }
@@ -202,18 +209,18 @@ void HybridStyleSheet::setThemeFromColorScheme(jsi::Runtime& rt) {
 
             return;
         default:
-            throw std::runtime_error("unable to set adaptive theme as your device doesn't support it.");
+            throw std::runtime_error("Unistyles: Unable to set adaptive theme as your device doesn't support it.");
     }
 }
 
 void HybridStyleSheet::loadExternalMethods(const jsi::Value& thisValue, jsi::Runtime& rt) {
     auto jsMethods = thisValue.getObject(rt).getProperty(rt, "jsMethods");
 
-    helpers::assertThat(rt, jsMethods.isObject(), "can't find jsMethods.");
+    helpers::assertThat(rt, jsMethods.isObject(), "Unistyles: Can't find jsMethods.");
 
     auto maybeProcessColorFn = jsMethods.asObject(rt).getProperty(rt, "processColor");
 
-    helpers::assertThat(rt, maybeProcessColorFn.isObject(), "can't load processColor function from JS.");
+    helpers::assertThat(rt, maybeProcessColorFn.isObject(), "Unistyles: Can't load processColor function from JS.");
 
     auto processColorFn = maybeProcessColorFn.asObject(rt).asFunction(rt);
     auto& registry = core::UnistylesRegistry::get();
@@ -222,19 +229,102 @@ void HybridStyleSheet::loadExternalMethods(const jsi::Value& thisValue, jsi::Run
     state.registerProcessColorFunction(std::move(processColorFn));
 }
 
-void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependency> dependencies) {
-    auto& registry = core::UnistylesRegistry::get();
-    auto parser = parser::Parser(this->_unistylesRuntime);
-    auto dependencyMap = registry.buildDependencyMap(dependencies);
-    auto& rt = this->_unistylesRuntime->getRuntime();
+void HybridStyleSheet::registerHooks(jsi::Runtime& rt) {
+    this->_unistylesCommitHook = std::make_shared<core::UnistylesCommitHook>(this->_uiManager);
+    this->_unistylesMountHook = std::make_shared<core::UnistylesMountHook>(this->_uiManager, rt);
+}
 
-    if (dependencyMap.size() == 0) {
+void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependency> unistylesDependencies) {
+    if (this->_unistylesRuntime == nullptr) {
         return;
     }
 
-    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap);
+    this->_unistylesRuntime->runOnJSThread([this, unistylesDependencies](jsi::Runtime& rt){
+        auto& registry = core::UnistylesRegistry::get();
+        auto parser = parser::Parser(this->_unistylesRuntime);
+        auto dependencies = std::move(unistylesDependencies);
 
-    auto shadowLeafUpdates = parser.dependencyMapToShadowLeafUpdates(dependencyMap);
+        // re-compute new breakpoint
+        auto dimensionsIt = std::find(dependencies.begin(), dependencies.end(), UnistyleDependency::DIMENSIONS);
+
+        if (dimensionsIt != dependencies.end()) {
+            registry.getState(rt).computeCurrentBreakpoint(this->_unistylesRuntime->getScreen().width);
+        }
 
-    shadow::ShadowTreeManager::updateShadowTree(rt, shadowLeafUpdates);
+        // check if color scheme changed and then if Unistyles state depend on it (adaptive themes)
+        auto colorSchemeIt = std::find(dependencies.begin(), dependencies.end(), UnistyleDependency::COLORSCHEME);
+        auto hasNewColorScheme = colorSchemeIt != dependencies.end();
+
+        // 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, hasNewColorScheme, dependencies.size() > 1);
+
+        if (hasNewColorScheme) {
+            this->_unistylesRuntime->includeDependenciesForColorSchemeChange(dependencies);
+        }
+
+        auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
+
+        if (dependencyMap.size() == 0) {
+            this->notifyJSListeners(dependencies);
+
+            return;
+        }
+
+        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets);
+        parser.rebuildShadowLeafUpdates(dependencyMap);
+        
+        this->notifyJSListeners(dependencies);
+        shadow::ShadowTreeManager::updateShadowTree(rt);
+    });
+}
+
+void HybridStyleSheet::onImeChange() {
+    if (this->_unistylesRuntime == nullptr) {
+        return;
+    }
+
+    this->_unistylesRuntime->runOnJSThread([this](jsi::Runtime& rt){
+        auto& registry = core::UnistylesRegistry::get();
+        auto parser = parser::Parser(this->_unistylesRuntime);
+
+        std::vector<UnistyleDependency> dependencies{UnistyleDependency::IME};
+
+        this->notifyJSListeners(dependencies);
+
+        auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
+
+        if (dependencyMap.size() == 0) {
+            return;
+        }
+
+        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, {});
+        parser.rebuildShadowLeafUpdates(dependencyMap);
+        shadow::ShadowTreeManager::updateShadowTree(rt);
+    });
+}
+
+void HybridStyleSheet::notifyJSListeners(std::vector<UnistyleDependency>& dependencies) {
+    if (dependencies.size() > 0) {
+        std::for_each(this->_changeListeners.begin(), this->_changeListeners.end(), [&](auto& listener){
+            (*listener)(dependencies);
+        });
+    }
+}
+
+std::function<void ()> HybridStyleSheet::addChangeListener(const std::function<void (const std::vector<UnistyleDependency>&)>& onChanged) {
+    auto listener = std::make_unique<std::function<void(std::vector<UnistyleDependency>&)>>(onChanged);
+
+    this->_changeListeners.push_back(std::move(listener));
+
+    return [this, listenerPtr = this->_changeListeners.back().get()](){
+        auto it = std::find_if(this->_changeListeners.begin(), this->_changeListeners.end(), [listenerPtr](auto& ptr) {
+            return ptr.get() == listenerPtr;
+        });
+
+        if (it != this->_changeListeners.end()) {
+            this->_changeListeners.erase(it);
+        }
+    };
 }

package/cxx/hybridObjects/HybridStyleSheet.h

@@ -9,21 +9,27 @@
 #include "Constants.h"
 #include "Breakpoints.h"
 #include "Parser.h"
-#include "ShadowTreeManager.h"
 #include "UnistylesCommitHook.h"
+#include "UnistylesMountHook.h"
 
 using namespace margelo::nitro::unistyles;
 using namespace facebook::react;
 
 struct HybridStyleSheet: public HybridUnistylesStyleSheetSpec {
     HybridStyleSheet(std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime, std::shared_ptr<UIManager> uiManager)
-        : HybridObject(TAG), _unistylesRuntime{unistylesRuntime} {
-            this->_unistylesCommitHook = std::make_shared<core::UnistylesCommitHook>(uiManager, unistylesRuntime);
+        : HybridObject(TAG), _unistylesRuntime{unistylesRuntime}, _uiManager{uiManager} {
             this->_unistylesRuntime->registerPlatformListener(
                   std::bind(&HybridStyleSheet::onPlatformDependenciesChange, this, std::placeholders::_1)
             );
+            this->_unistylesRuntime->registerImeListener(
+                  std::bind(&HybridStyleSheet::onImeChange, this)
+            );
       }
 
+    ~HybridStyleSheet() {
+        this->_unistylesRuntime->unregisterPlatformListeners();
+    }
+
     jsi::Value create(jsi::Runtime& rt,
                       const jsi::Value& thisValue,
                       const jsi::Value* args,
@@ -32,19 +38,25 @@ struct HybridStyleSheet: public HybridUnistylesStyleSheetSpec {
                       const jsi::Value& thisValue,
                       const jsi::Value* args,
                       size_t count);
+    jsi::Value init(jsi::Runtime& rt,
+                      const jsi::Value& thisValue,
+                      const jsi::Value* args,
+                      size_t count);
 
     void loadHybridMethods() override {
         HybridUnistylesStyleSheetSpec::loadHybridMethods();
 
         registerHybrids(this, [](Prototype& prototype) {
+            prototype.registerRawHybridMethod("init", 1, &HybridStyleSheet::init);
             prototype.registerRawHybridMethod("create", 1, &HybridStyleSheet::create);
             prototype.registerRawHybridMethod("configure", 1, &HybridStyleSheet::configure);
         });
     };
 
     double getHairlineWidth() override;
-    double get___unid() override;
-    
+    double getUnid() override;
+    std::function<void ()> addChangeListener(const std::function<void (const std::vector<UnistyleDependency> &)>& onChanged) override;
+
 private:
     void parseSettings(jsi::Runtime& rt, jsi::Object settings);
     void parseBreakpoints(jsi::Runtime& rt, jsi::Object breakpoints);
@@ -52,10 +64,16 @@ private:
     void verifyAndSelectTheme(jsi::Runtime &rt);
     void setThemeFromColorScheme(jsi::Runtime& rt);
     void loadExternalMethods(const jsi::Value& thisValue, jsi::Runtime& rt);
+    void registerHooks(jsi::Runtime& rt);
     void onPlatformDependenciesChange(std::vector<UnistyleDependency> dependencies);
+    void onImeChange();
+    void notifyJSListeners(std::vector<UnistyleDependency>& dependencies);
 
     double __unid = -1;
+    std::vector<std::unique_ptr<const std::function<void(std::vector<UnistyleDependency>&)>>> _changeListeners{};
     std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
     std::shared_ptr<core::UnistylesCommitHook> _unistylesCommitHook;
+    std::shared_ptr<core::UnistylesMountHook> _unistylesMountHook;
+    std::shared_ptr<UIManager> _uiManager;
 };
 

package/cxx/hybridObjects/HybridUnistylesRuntime.cpp

@@ -58,7 +58,7 @@ double HybridUnistylesRuntime::getFontScale() {
 };
 
 void HybridUnistylesRuntime::setTheme(const std::string &themeName) {
-    helpers::assertThat(*_rt, !this->getHasAdaptiveThemes(), "You're trying to set theme to: '" + themeName + "', but adaptiveThemes are enabled.");
+    helpers::assertThat(*_rt, !this->getHasAdaptiveThemes(), "Unistyles: You're trying to set theme to: '" + themeName + "', but adaptiveThemes are enabled.");
 
     auto& state = core::UnistylesRegistry::get().getState(*_rt);
 
@@ -71,7 +71,7 @@ void HybridUnistylesRuntime::setAdaptiveThemes(bool isEnabled) {
 
     std::vector<UnistyleDependency> changedDependencies{};
 
-    changedDependencies.reserve(5);
+    changedDependencies.reserve(3);
 
     bool hadAdaptiveThemes = this->getHasAdaptiveThemes();
 
@@ -92,6 +92,11 @@ void HybridUnistylesRuntime::setAdaptiveThemes(bool isEnabled) {
 
     // if user enabled adaptive themes, then we need to make sure
     // we selected theme based on color scheme
+    this->calculateNewThemeAndDependencies(changedDependencies);
+    this->_onDependenciesChange(changedDependencies);
+};
+
+void HybridUnistylesRuntime::calculateNewThemeAndDependencies(std::vector<UnistyleDependency>& changedDependencies) {
     auto& state = core::UnistylesRegistry::get().getState(*_rt);
     auto colorScheme = this->getColorScheme();
     auto currentThemeName = this->getThemeName();
@@ -105,9 +110,25 @@ void HybridUnistylesRuntime::setAdaptiveThemes(bool isEnabled) {
 
         state.setTheme(nextTheme);
     }
+}
 
-    this->_onDependenciesChange(changedDependencies);
-};
+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);
+
+    if (count == 1) {
+        helpers::assertThat(rt, args[0].isString(), "UnistylesRuntime.getTheme expected to be called with string.");
+
+        auto themeName = args[0].asString(rt).utf8(rt);
+
+        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.getCurrentJSTheme();
+}
 
 jsi::Value HybridUnistylesRuntime::updateTheme(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
     helpers::assertThat(rt, count == 2, "UnistylesRuntime.updateTheme expected to be called with 2 arguments.");
@@ -117,7 +138,7 @@ jsi::Value HybridUnistylesRuntime::updateTheme(jsi::Runtime &rt, const jsi::Valu
     auto& registry = core::UnistylesRegistry::get();
     auto themeName = args[0].asString(rt).utf8(rt);
 
-    helpers::assertThat(rt, args[1].asObject(rt).isFunction(rt), "second argument expected to be a function.");
+    helpers::assertThat(rt, args[1].asObject(rt).isFunction(rt), "UnistylesRuntime.updateTheme expected second argument to be a function.");
 
     registry.updateTheme(rt, themeName, args[1].asObject(rt).asFunction(rt));
 
@@ -155,7 +176,6 @@ UnistylesCxxMiniRuntime HybridUnistylesRuntime::getMiniRuntime() {
     UnistylesCxxMiniRuntime cxxMiniRuntime{
         this->getThemeName(),
         this->getBreakpoint(),
-        nativeMiniRuntime.orientation,
         this->getHasAdaptiveThemes(),
         nativeMiniRuntime.colorScheme,
         nativeMiniRuntime.screen,
@@ -165,7 +185,9 @@ UnistylesCxxMiniRuntime HybridUnistylesRuntime::getMiniRuntime() {
         nativeMiniRuntime.fontScale,
         nativeMiniRuntime.rtl,
         nativeMiniRuntime.statusBar,
-        nativeMiniRuntime.navigationBar
+        nativeMiniRuntime.navigationBar,
+        nativeMiniRuntime.isPortrait,
+        nativeMiniRuntime.isLandscape
     };
 
     return cxxMiniRuntime;
@@ -178,7 +200,6 @@ jsi::Value HybridUnistylesRuntime::getMiniRuntimeAsValue(jsi::Runtime& rt) {
     // auto generated by nitro, but can't be accessed due to static inline function
     obj.setProperty(rt, "themeName", JSIConverter<std::optional<std::string>>::toJSI(rt, miniRuntime.themeName));
     obj.setProperty(rt, "breakpoint", JSIConverter<std::optional<std::string>>::toJSI(rt, miniRuntime.breakpoint));
-    obj.setProperty(rt, "orientation", JSIConverter<Orientation>::toJSI(rt, miniRuntime.orientation));
     obj.setProperty(rt, "hasAdaptiveThemes", JSIConverter<bool>::toJSI(rt, miniRuntime.hasAdaptiveThemes));
     obj.setProperty(rt, "colorScheme", JSIConverter<ColorScheme>::toJSI(rt, miniRuntime.colorScheme));
     obj.setProperty(rt, "screen", JSIConverter<Dimensions>::toJSI(rt, miniRuntime.screen));
@@ -189,6 +210,8 @@ jsi::Value HybridUnistylesRuntime::getMiniRuntimeAsValue(jsi::Runtime& rt) {
     obj.setProperty(rt, "rtl", JSIConverter<bool>::toJSI(rt, miniRuntime.rtl));
     obj.setProperty(rt, "statusBar", JSIConverter<Dimensions>::toJSI(rt, miniRuntime.statusBar));
     obj.setProperty(rt, "navigationBar", JSIConverter<Dimensions>::toJSI(rt, miniRuntime.navigationBar));
+    obj.setProperty(rt, "isPortrait", JSIConverter<bool>::toJSI(rt, miniRuntime.isPortrait));
+    obj.setProperty(rt, "isLandscape", JSIConverter<bool>::toJSI(rt, miniRuntime.isLandscape));
 
     return obj;
 }
@@ -201,3 +224,23 @@ void HybridUnistylesRuntime::registerPlatformListener(const std::function<void(s
     this->_nativePlatform.registerPlatformListener(listener);
     this->_onDependenciesChange = listener;
 }
+
+void HybridUnistylesRuntime::registerImeListener(const std::function<void()>& listener) {
+    this->_nativePlatform.registerImeListener(listener);
+}
+
+void HybridUnistylesRuntime::unregisterPlatformListeners() {
+    this->_nativePlatform.unregisterPlatformListeners();
+}
+
+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()) {
+        return;
+    }
+
+    this->calculateNewThemeAndDependencies(deps);
+}

package/cxx/hybridObjects/HybridUnistylesRuntime.h

@@ -13,8 +13,13 @@
 namespace margelo::nitro::unistyles {
 
 struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
-    HybridUnistylesRuntime(Unistyles::HybridNativePlatformSpecCxx nativePlatform, jsi::Runtime& rt) : HybridObject(TAG), _nativePlatform{nativePlatform}, _rt{&rt} {}
+    HybridUnistylesRuntime(Unistyles::HybridNativePlatformSpecCxx nativePlatform, jsi::Runtime& rt, std::function<void(std::function<void(jsi::Runtime&)>&&)> runOnJSThread)
+        : HybridObject(TAG), _nativePlatform{nativePlatform}, _rt{&rt}, runOnJSThread(std::move(runOnJSThread)) {}
 
+    jsi::Value getTheme(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
     jsi::Value updateTheme(jsi::Runtime& rt,
                             const jsi::Value& thisValue,
                             const jsi::Value* args,
@@ -32,6 +37,7 @@ struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
         HybridUnistylesRuntimeSpec::loadHybridMethods();
 
         registerHybrids(this, [](Prototype& prototype) {
+            prototype.registerRawHybridMethod("getTheme", 1, &HybridUnistylesRuntime::getTheme);
             prototype.registerRawHybridMethod("updateTheme", 1, &HybridUnistylesRuntime::updateTheme);
             prototype.registerRawHybridMethod("createHybridStatusBar", 0, &HybridUnistylesRuntime::createHybridStatusBar);
             prototype.registerRawHybridMethod("createHybridNavigationBar", 0, &HybridUnistylesRuntime::createHybridNavigationBar);
@@ -50,6 +56,8 @@ struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
     double getPixelRatio() override;
     double getFontScale() override;
     void registerPlatformListener(const std::function<void(std::vector<UnistyleDependency>)>& listener);
+    void registerImeListener(const std::function<void()>& listener);
+    void unregisterPlatformListeners();
 
     void setTheme(const std::string &themeName) override;
     void setAdaptiveThemes(bool isEnabled) override;
@@ -58,6 +66,9 @@ struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
     UnistylesCxxMiniRuntime getMiniRuntime() override;
     jsi::Value getMiniRuntimeAsValue(jsi::Runtime& rt);
     jsi::Runtime& getRuntime();
+    void includeDependenciesForColorSchemeChange(std::vector<UnistyleDependency>& deps);
+    void calculateNewThemeAndDependencies(std::vector<UnistyleDependency>& deps);
+    std::function<void(std::function<void(jsi::Runtime&)>&&)> runOnJSThread;
 
 private:
     jsi::Runtime* _rt;