react-native-unistyles 3.0.0-alpha.4 → 3.0.0-alpha.40

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -9,24 +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, false, "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) {
-        registry.removeStyleSheet(this->__unid);
-    }
+    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;
 
@@ -45,11 +46,7 @@ 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") {
@@ -74,7 +71,22 @@ jsi::Value HybridStyleSheet::configure(jsi::Runtime &rt, const jsi::Value &thisV
     });
 
     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();
 }
@@ -116,7 +128,7 @@ void HybridStyleSheet::parseSettings(jsi::Runtime &rt, jsi::Object settings) {
 void HybridStyleSheet::parseBreakpoints(jsi::Runtime &rt, jsi::Object breakpoints){
     helpers::Breakpoints sortedBreakpoints = helpers::jsiBreakpointsToVecPairs(rt, std::move(breakpoints));
 
-    helpers::assertThat(rt, sortedBreakpoints.size() > 0, "StyleSheet.configure's breakpoints can't be empty.");
+    helpers::assertThat(rt, !sortedBreakpoints.empty(), "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();
@@ -132,11 +144,10 @@ void HybridStyleSheet::parseThemes(jsi::Runtime &rt, jsi::Object themes) {
     helpers::enumerateJSIObject(rt, themes, [&](const std::string& propertyName, jsi::Value& propertyValue){
         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);
 
@@ -186,7 +197,7 @@ void HybridStyleSheet::verifyAndSelectTheme(jsi::Runtime &rt) {
 
 void HybridStyleSheet::setThemeFromColorScheme(jsi::Runtime& rt) {
     auto& state = core::UnistylesRegistry::get().getState(rt);
-    ColorScheme colorScheme = static_cast<ColorScheme>(this->_unistylesRuntime->getColorScheme());
+    auto colorScheme = static_cast<ColorScheme>(this->_unistylesRuntime->getColorScheme());
 
     switch (colorScheme) {
         case ColorScheme::LIGHT:
@@ -218,19 +229,139 @@ void HybridStyleSheet::loadExternalMethods(const jsi::Value& thisValue, jsi::Run
     state.registerProcessColorFunction(std::move(processColorFn));
 }
 
+void HybridStyleSheet::registerHooks(jsi::Runtime& rt) {
+    // cleanup Shadow updates
+    core::UnistylesRegistry::get().trafficController.restore();
+
+    this->_unistylesCommitHook = std::make_shared<core::UnistylesCommitHook>(this->_uiManager);
+    this->_unistylesMountHook = std::make_shared<core::UnistylesMountHook>(this->_uiManager, this->_unistylesRuntime);
+}
+
 void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependency> dependencies) {
+    // this event listener is triggered from C++ module, and it's only about theme / adaptive theme changes
+    if (dependencies.size() == 0) {
+        return;
+    }
+
     auto& registry = core::UnistylesRegistry::get();
-    auto parser = parser::Parser(this->_unistylesRuntime);
-    auto dependencyMap = registry.buildDependencyMap(dependencies);
     auto& rt = this->_unistylesRuntime->getRuntime();
+    auto parser = parser::Parser(this->_unistylesRuntime);
+    auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
+
+    if (dependencyMap.empty()) {
+        this->notifyJSListeners(dependencies);
+
+        return;
+    }
+
+    // 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);
+
+    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, std::nullopt);
+    parser.rebuildShadowLeafUpdates(rt, dependencyMap);
+
+    this->notifyJSListeners(dependencies);
+    shadow::ShadowTreeManager::updateShadowTree(UIManagerBinding::getBinding(rt)->getUIManager().getShadowTreeRegistry());
+}
+
+void HybridStyleSheet::onPlatformNativeDependenciesChange(std::vector<UnistyleDependency> dependencies, UnistylesNativeMiniRuntime miniRuntime) {
+    // this event listener is triggered from Native platform
+    if (dependencies.size() == 0 || this->_unistylesRuntime == nullptr) {
+        return;
+    }
+
+    this->_unistylesRuntime->runOnJSThread([this, dependencies, miniRuntime](jsi::Runtime& rt){
+        auto& registry = core::UnistylesRegistry::get();
+        auto parser = parser::Parser(this->_unistylesRuntime);
+        auto unistyleDependencies = std::move(dependencies);
+
+        // 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);
+        }
+
+        // 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();
+
+        if (hasNewColorScheme) {
+            this->_unistylesRuntime->includeDependenciesForColorSchemeChange(unistyleDependencies);
+        }
+
+        auto dependencyMap = registry.buildDependencyMap(rt, unistyleDependencies);
+
+        if (dependencyMap.empty()) {
+            this->notifyJSListeners(unistyleDependencies);
+
+            return;
+        }
+
+        // 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);
+
+        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, miniRuntime);
+        parser.rebuildShadowLeafUpdates(rt, dependencyMap);
 
-    if (dependencyMap.size() == 0) {
+        this->notifyJSListeners(unistyleDependencies);
+        shadow::ShadowTreeManager::updateShadowTree(UIManagerBinding::getBinding(rt)->getUIManager().getShadowTreeRegistry());
+    });
+}
+
+void HybridStyleSheet::onImeChange(UnistylesNativeMiniRuntime miniRuntime) {
+    if (this->_unistylesRuntime == nullptr) {
         return;
     }
 
-    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap);
+    this->_unistylesRuntime->runOnJSThread([this, miniRuntime](jsi::Runtime& rt){
+        std::vector<UnistyleDependency> dependencies{UnistyleDependency::IME};
+        auto& registry = core::UnistylesRegistry::get();
+        auto parser = parser::Parser(this->_unistylesRuntime);
+        auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
+
+        if (dependencyMap.empty()) {
+            this->notifyJSListeners(dependencies);
+
+            return;
+        }
+
+        // we don't care about other unmounted stylesheets as their not visible
+        // so user won't see any changes
+        std::vector<std::shared_ptr<core::StyleSheet>> dependentStyleSheets;
+
+        parser.rebuildUnistylesInDependencyMap(rt, dependencyMap, dependentStyleSheets, miniRuntime);
+        parser.rebuildShadowLeafUpdates(rt, dependencyMap);
+
+        this->notifyJSListeners(dependencies);
+        shadow::ShadowTreeManager::updateShadowTree(UIManagerBinding::getBinding(rt)->getUIManager().getShadowTreeRegistry());
+    });
+}
+
+void HybridStyleSheet::notifyJSListeners(std::vector<UnistyleDependency>& dependencies) {
+    if (!dependencies.empty()) {
+        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);
 
-    auto shadowLeafUpdates = parser.dependencyMapToShadowLeafUpdates(dependencyMap);
+    this->_changeListeners.push_back(std::move(listener));
 
-    shadow::ShadowTreeManager::updateShadowTree(rt, shadowLeafUpdates);
+    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,30 @@
 #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->registerNativePlatformListener(
+                  std::bind(&HybridStyleSheet::onPlatformNativeDependenciesChange, this, std::placeholders::_1, std::placeholders::_2)
+            );
+            this->_unistylesRuntime->registerImeListener(
+                  std::bind(&HybridStyleSheet::onImeChange, this, std::placeholders::_1)
+            );
       }
 
+    ~HybridStyleSheet() {
+        this->_unistylesRuntime->unregisterNativePlatformListeners();
+    }
+
     jsi::Value create(jsi::Runtime& rt,
                       const jsi::Value& thisValue,
                       const jsi::Value* args,
@@ -32,19 +41,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 +67,17 @@ 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 onPlatformNativeDependenciesChange(std::vector<UnistyleDependency> dependencies, UnistylesNativeMiniRuntime miniRuntime);
+    void onImeChange(UnistylesNativeMiniRuntime miniRuntime);
+    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

@@ -4,7 +4,7 @@
 using namespace margelo::nitro::unistyles;
 
 ColorScheme HybridUnistylesRuntime::getColorScheme() {
-    int colorScheme = this->_nativePlatform.getColorScheme();
+    auto colorScheme = this->_nativePlatform.getColorScheme();
 
     return static_cast<ColorScheme>(colorScheme);
 }
@@ -44,7 +44,7 @@ Insets HybridUnistylesRuntime::getInsets() {
 };
 
 Orientation HybridUnistylesRuntime::getOrientation() {
-    int orientation = this->_nativePlatform.getOrientation();
+    auto orientation = this->_nativePlatform.getOrientation();
 
     return static_cast<Orientation>(orientation);
 };
@@ -57,6 +57,18 @@ double HybridUnistylesRuntime::getFontScale() {
     return this->_nativePlatform.getFontScale();
 };
 
+std::unordered_map<std::string, double> HybridUnistylesRuntime::getBreakpoints() {
+    auto& state = core::UnistylesRegistry::get().getState(*_rt);
+    auto sortedBreakpointPairs = state.getSortedBreakpointPairs();
+    std::unordered_map<std::string, double> breakpoints{};
+
+    std::for_each(sortedBreakpointPairs.begin(), sortedBreakpointPairs.end(), [&breakpoints](std::pair<std::string, double>& pair){
+        breakpoints[pair.first] = pair.second;
+    });
+
+    return breakpoints;
+}
+
 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.");
 
@@ -71,7 +83,7 @@ void HybridUnistylesRuntime::setAdaptiveThemes(bool isEnabled) {
 
     std::vector<UnistyleDependency> changedDependencies{};
 
-    changedDependencies.reserve(5);
+    changedDependencies.reserve(3);
 
     bool hadAdaptiveThemes = this->getHasAdaptiveThemes();
 
@@ -92,6 +104,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 +122,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.");
@@ -155,7 +188,6 @@ UnistylesCxxMiniRuntime HybridUnistylesRuntime::getMiniRuntime() {
     UnistylesCxxMiniRuntime cxxMiniRuntime{
         this->getThemeName(),
         this->getBreakpoint(),
-        nativeMiniRuntime.orientation,
         this->getHasAdaptiveThemes(),
         nativeMiniRuntime.colorScheme,
         nativeMiniRuntime.screen,
@@ -165,20 +197,44 @@ UnistylesCxxMiniRuntime HybridUnistylesRuntime::getMiniRuntime() {
         nativeMiniRuntime.fontScale,
         nativeMiniRuntime.rtl,
         nativeMiniRuntime.statusBar,
-        nativeMiniRuntime.navigationBar
+        nativeMiniRuntime.navigationBar,
+        nativeMiniRuntime.isPortrait,
+        nativeMiniRuntime.isLandscape
+    };
+
+    return cxxMiniRuntime;
+}
+
+UnistylesCxxMiniRuntime HybridUnistylesRuntime::buildMiniRuntimeFromNativeRuntime(UnistylesNativeMiniRuntime& nativeMiniRuntime) {
+    UnistylesCxxMiniRuntime cxxMiniRuntime{
+        this->getThemeName(),
+        this->getBreakpoint(),
+        this->getHasAdaptiveThemes(),
+        nativeMiniRuntime.colorScheme,
+        nativeMiniRuntime.screen,
+        nativeMiniRuntime.contentSizeCategory,
+        nativeMiniRuntime.insets,
+        nativeMiniRuntime.pixelRatio,
+        nativeMiniRuntime.fontScale,
+        nativeMiniRuntime.rtl,
+        nativeMiniRuntime.statusBar,
+        nativeMiniRuntime.navigationBar,
+        nativeMiniRuntime.isPortrait,
+        nativeMiniRuntime.isLandscape
     };
 
     return cxxMiniRuntime;
 }
 
-jsi::Value HybridUnistylesRuntime::getMiniRuntimeAsValue(jsi::Runtime& rt) {
-    auto miniRuntime = this->getMiniRuntime();
+jsi::Value HybridUnistylesRuntime::getMiniRuntimeAsValue(jsi::Runtime& rt, std::optional<UnistylesNativeMiniRuntime> maybeMiniRuntime) {
     jsi::Object obj(rt);
+    auto miniRuntime = maybeMiniRuntime.has_value()
+        ? this->buildMiniRuntimeFromNativeRuntime(maybeMiniRuntime.value())
+        : this->getMiniRuntime();
 
     // 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,15 +245,41 @@ 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;
 }
 
-jsi::Runtime& HybridUnistylesRuntime::getRuntime() {
-    return *this->_rt;
+void HybridUnistylesRuntime::registerPlatformListener(const std::function<void (std::vector<UnistyleDependency>)>& listener) {
+    this->_onDependenciesChange = listener;
 }
 
-void HybridUnistylesRuntime::registerPlatformListener(const std::function<void(std::vector<UnistyleDependency>)>& listener) {
+void HybridUnistylesRuntime::registerNativePlatformListener(const std::function<void(std::vector<UnistyleDependency>, UnistylesNativeMiniRuntime)>& listener) {
     this->_nativePlatform.registerPlatformListener(listener);
-    this->_onDependenciesChange = listener;
+    this->_onNativeDependenciesChange = listener;
+}
+
+void HybridUnistylesRuntime::registerImeListener(const std::function<void(UnistylesNativeMiniRuntime)>& listener) {
+    this->_nativePlatform.registerImeListener(listener);
+}
+
+void HybridUnistylesRuntime::unregisterNativePlatformListeners() {
+    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);
+}
+
+jsi::Runtime& HybridUnistylesRuntime::getRuntime() {
+    return *this->_rt;
 }

package/cxx/hybridObjects/HybridUnistylesRuntime.h

@@ -2,7 +2,7 @@
 
 #include "HybridUnistylesRuntimeSpec.hpp"
 #include "HybridNativePlatformSpec.hpp"
-#include "Unistyles-Swift-Cxx-Umbrella.hpp"
+#include "NativePlatform.h"
 #include "UnistylesState.h"
 #include "HybridUnistylesStatusBarSpec.hpp"
 #include "HybridNavigationBar.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,14 +56,23 @@ struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
     double getPixelRatio() override;
     double getFontScale() override;
     void registerPlatformListener(const std::function<void(std::vector<UnistyleDependency>)>& listener);
+    void registerNativePlatformListener(const std::function<void(std::vector<UnistyleDependency>, UnistylesNativeMiniRuntime)>& listener);
+    void registerImeListener(const std::function<void(UnistylesNativeMiniRuntime)>& listener);
+    void unregisterNativePlatformListeners();
 
     void setTheme(const std::string &themeName) override;
     void setAdaptiveThemes(bool isEnabled) override;
     void setImmersiveMode(bool isEnabled) override;
     void setRootViewBackgroundColor(double color) override;
     UnistylesCxxMiniRuntime getMiniRuntime() override;
-    jsi::Value getMiniRuntimeAsValue(jsi::Runtime& rt);
+    std::unordered_map<std::string, double> getBreakpoints() override;
+
     jsi::Runtime& getRuntime();
+    UnistylesCxxMiniRuntime buildMiniRuntimeFromNativeRuntime(UnistylesNativeMiniRuntime& nativeMiniRuntime);
+    jsi::Value getMiniRuntimeAsValue(jsi::Runtime& rt, std::optional<UnistylesNativeMiniRuntime> maybeMiniRuntime);
+    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;
@@ -65,6 +80,7 @@ private:
     std::shared_ptr<HybridStatusBar> _statusBar;
     Unistyles::HybridNativePlatformSpecCxx _nativePlatform;
     std::function<void(std::vector<UnistyleDependency>)> _onDependenciesChange;
+    std::function<void(std::vector<UnistyleDependency>, UnistylesNativeMiniRuntime)> _onNativeDependenciesChange;
 };
 
 }