react-native-unistyles 2.10.0 → 3.0.0-alpha.10

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -0,0 +1,241 @@
+#include "HybridStyleSheet.h"
+
+using namespace facebook::react;
+
+double HybridStyleSheet::getHairlineWidth() {
+    auto pixelRatio = this->_unistylesRuntime->getPixelRatio();
+    auto nearestPixel = static_cast<int>(std::trunc(pixelRatio * 0.4));
+
+    return nearestPixel / pixelRatio;
+}
+
+double HybridStyleSheet::get___unid() {
+    return this->__unid;
+}
+
+jsi::Value HybridStyleSheet::create(jsi::Runtime& rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) {
+    // 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();
+    int unid = arguments[1].asNumber();
+
+    jsi::Object rawStyleSheet = arguments[0].asObject(rt);
+    auto registeredStyleSheet = registry.addStyleSheetFromValue(rt, std::move(rawStyleSheet), unid);
+
+    this->__unid = registeredStyleSheet->tag;
+
+    auto parser = parser::Parser(this->_unistylesRuntime);
+
+    parser.buildUnistyles(rt, registeredStyleSheet);
+    parser.parseUnistyles(rt, registeredStyleSheet);
+
+    auto style = std::make_shared<core::HostStyle>(registeredStyleSheet, this->_unistylesRuntime);
+    auto styleHostObject = jsi::Object::createFromHostObject(rt, style);
+
+    return styleHostObject;
+}
+
+jsi::Value HybridStyleSheet::configure(jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *arguments, size_t count) {
+    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(), "StyleSheet.configure's settings must be an object.");
+
+            return this->parseSettings(rt, propertyValue.asObject(rt));
+        }
+
+        if (propertyName == "breakpoints") {
+            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(), "StyleSheet.configure's themes must be an object.");
+
+            return this->parseThemes(rt, propertyValue.asObject(rt));
+        }
+
+        helpers::assertThat(rt, false, "StyleSheet.configure received unexpected key: '" + std::string(propertyName) + "'.");
+    });
+
+    verifyAndSelectTheme(rt);
+    loadExternalMethods(thisVal, rt);
+
+    return jsi::Value::undefined();
+}
+
+void HybridStyleSheet::parseSettings(jsi::Runtime &rt, jsi::Object settings) {
+    auto& registry = core::UnistylesRegistry::get();
+
+    helpers::enumerateJSIObject(rt, settings, [&](const std::string& propertyName, jsi::Value& propertyValue){
+        if (propertyName == "adaptiveThemes") {
+            helpers::assertThat(rt, propertyValue.isBool(), "StyleSheet.configure's adaptiveThemes must be of boolean type.");
+
+            registry.setPrefersAdaptiveThemes(rt, propertyValue.asBool());
+
+            return;
+        }
+
+        if (propertyName == "initialTheme") {
+            if (propertyValue.isObject()) {
+                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(), "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(), "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, "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, "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);
+
+    registry.registerBreakpoints(rt, sortedBreakpoints);
+    state.computeCurrentBreakpoint(this->_unistylesRuntime->getScreen().width);
+}
+
+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(), "StyleSheet.configure's registered theme '" + propertyName + "' must be an object.");
+
+        registry.registerTheme(rt, propertyName, propertyValue.asObject(rt));
+    });
+}
+
+
+void HybridStyleSheet::verifyAndSelectTheme(jsi::Runtime &rt) {
+    auto& state = core::UnistylesRegistry::get().getState(rt);
+
+    bool hasInitialTheme = state.hasInitialTheme();
+    bool prefersAdaptiveThemes = state.getPrefersAdaptiveThemes();
+    bool hasAdaptiveThemes = state.hasAdaptiveThemes();
+    std::vector<std::string> registeredThemeNames = state.getRegisteredThemeNames();
+    bool hasSingleTheme = registeredThemeNames.size() == 1;
+
+    // user tries to enable adaptive themes, but didn't register both 'light' and 'dark' themes
+    if (prefersAdaptiveThemes && !hasAdaptiveThemes) {
+        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
+    // do nothing - user must select initial theme during runtime
+    if (!hasInitialTheme && !hasAdaptiveThemes && !hasSingleTheme) {
+        return;
+    }
+
+    // user didn't select initial theme nor can have adaptive themes, but registered exactly 1 theme
+    // preselect it!
+    if (!hasInitialTheme && !hasAdaptiveThemes && hasSingleTheme) {
+        return state.setTheme(registeredThemeNames.at(0));
+    }
+
+    // user didn't select initial theme, but has adaptive themes
+    // simply select theme based on color scheme
+    if (!hasInitialTheme && hasAdaptiveThemes) {
+        return this->setThemeFromColorScheme(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, "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), "Unistyles: You're trying to select theme '" + selectedTheme + "' but it wasn't registered.");
+
+    state.setTheme(selectedTheme);
+}
+
+void HybridStyleSheet::setThemeFromColorScheme(jsi::Runtime& rt) {
+    auto& state = core::UnistylesRegistry::get().getState(rt);
+    ColorScheme colorScheme = static_cast<ColorScheme>(this->_unistylesRuntime->getColorScheme());
+
+    switch (colorScheme) {
+        case ColorScheme::LIGHT:
+            state.setTheme("light");
+
+            return;
+        case ColorScheme::DARK:
+            state.setTheme("dark");
+
+            return;
+        default:
+            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(), "Unistyles: Can't find jsMethods.");
+
+    auto maybeProcessColorFn = jsMethods.asObject(rt).getProperty(rt, "processColor");
+
+    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();
+    auto& state = registry.getState(rt);
+
+    state.registerProcessColorFunction(std::move(processColorFn));
+}
+
+void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependency> dependencies) {
+    auto& registry = core::UnistylesRegistry::get();
+    auto parser = parser::Parser(this->_unistylesRuntime);
+    auto& rt = this->_unistylesRuntime->getRuntime();
+
+    // 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);
+
+    if (colorSchemeIt != dependencies.end()) {
+        this->_unistylesRuntime->includeDependenciesForColorSchemeChange(dependencies);
+    }
+
+    auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
+
+    if (dependencyMap.size() == 0) {
+        return;
+    }
+
+    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap);
+
+    auto shadowLeafUpdates = parser.dependencyMapToShadowLeafUpdates(dependencyMap);
+
+    shadow::ShadowTreeManager::updateShadowTree(rt, shadowLeafUpdates);
+}

package/cxx/hybridObjects/HybridStyleSheet.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <cmath>
+#include <jsi/jsi.h>
+#include "HybridUnistylesRuntime.h"
+#include "HybridUnistylesStyleSheetSpec.hpp"
+#include "HostStyle.h"
+#include "Helpers.h"
+#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);
+            this->_unistylesMountHook = std::make_shared<core::UnistylesMountHook>(uiManager, unistylesRuntime);
+            this->_unistylesRuntime->registerPlatformListener(
+                  std::bind(&HybridStyleSheet::onPlatformDependenciesChange, this, std::placeholders::_1)
+            );
+      }
+
+    jsi::Value create(jsi::Runtime& rt,
+                      const jsi::Value& thisValue,
+                      const jsi::Value* args,
+                      size_t count);
+    jsi::Value configure(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("create", 1, &HybridStyleSheet::create);
+            prototype.registerRawHybridMethod("configure", 1, &HybridStyleSheet::configure);
+        });
+    };
+
+    double getHairlineWidth() override;
+    double get___unid() override;
+    
+private:
+    void parseSettings(jsi::Runtime& rt, jsi::Object settings);
+    void parseBreakpoints(jsi::Runtime& rt, jsi::Object breakpoints);
+    void parseThemes(jsi::Runtime& rt, jsi::Object themes);
+    void verifyAndSelectTheme(jsi::Runtime &rt);
+    void setThemeFromColorScheme(jsi::Runtime& rt);
+    void loadExternalMethods(const jsi::Value& thisValue, jsi::Runtime& rt);
+    void onPlatformDependenciesChange(std::vector<UnistyleDependency> dependencies);
+
+    double __unid = -1;
+    std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+    std::shared_ptr<core::UnistylesCommitHook> _unistylesCommitHook;
+    std::shared_ptr<core::UnistylesMountHook> _unistylesMountHook;
+};
+

package/cxx/hybridObjects/HybridUnistylesRuntime.cpp

@@ -0,0 +1,218 @@
+#include "HybridUnistylesRuntime.h"
+#include "UnistylesState.h"
+
+using namespace margelo::nitro::unistyles;
+
+ColorScheme HybridUnistylesRuntime::getColorScheme() {
+    int colorScheme = this->_nativePlatform.getColorScheme();
+
+    return static_cast<ColorScheme>(colorScheme);
+}
+
+bool HybridUnistylesRuntime::getHasAdaptiveThemes() {
+    auto& state = core::UnistylesRegistry::get().getState(*_rt);
+
+    return state.hasAdaptiveThemes();
+};
+
+Dimensions HybridUnistylesRuntime::getScreen() {
+    return this->_nativePlatform.getScreenDimensions();
+};
+
+std::optional<std::string> HybridUnistylesRuntime::getThemeName() {
+    auto& state = core::UnistylesRegistry::get().getState(*_rt);
+
+    return state.getCurrentThemeName();
+};
+
+std::string HybridUnistylesRuntime::getContentSizeCategory() {
+    return this->_nativePlatform.getContentSizeCategory();
+};
+
+std::optional<std::string> HybridUnistylesRuntime::getBreakpoint() {
+    auto& state = core::UnistylesRegistry::get().getState(*_rt);
+
+    return state.getCurrentBreakpointName();
+};
+
+bool HybridUnistylesRuntime::getRtl() {
+    return this->_nativePlatform.getPrefersRtlDirection();
+}
+
+Insets HybridUnistylesRuntime::getInsets() {
+    return this->_nativePlatform.getInsets();
+};
+
+Orientation HybridUnistylesRuntime::getOrientation() {
+    int orientation = this->_nativePlatform.getOrientation();
+
+    return static_cast<Orientation>(orientation);
+};
+
+double HybridUnistylesRuntime::getPixelRatio() {
+    return this->_nativePlatform.getPixelRatio();
+};
+
+double HybridUnistylesRuntime::getFontScale() {
+    return this->_nativePlatform.getFontScale();
+};
+
+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.");
+
+    auto& state = core::UnistylesRegistry::get().getState(*_rt);
+
+    state.setTheme(themeName);
+    this->_onDependenciesChange({UnistyleDependency::THEME, UnistyleDependency::THEMENAME});
+};
+
+void HybridUnistylesRuntime::setAdaptiveThemes(bool isEnabled) {
+    auto& registry = core::UnistylesRegistry::get();
+
+    std::vector<UnistyleDependency> changedDependencies{};
+
+    changedDependencies.reserve(3);
+
+    bool hadAdaptiveThemes = this->getHasAdaptiveThemes();
+
+    registry.setPrefersAdaptiveThemes(*_rt, isEnabled);
+
+    bool haveAdaptiveThemes = this->getHasAdaptiveThemes();
+
+    if (hadAdaptiveThemes != haveAdaptiveThemes) {
+        changedDependencies.push_back(UnistyleDependency::ADAPTIVETHEMES);
+    }
+
+    // if user disabled it, or can't have adaptive themes, do nothing
+    if (!this->getHasAdaptiveThemes()) {
+        this->_onDependenciesChange(changedDependencies);
+
+        return;
+    }
+
+    // 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();
+    auto nextTheme = colorScheme == ColorScheme::LIGHT
+        ? "light"
+        : "dark";
+
+    if (!currentThemeName.has_value() || nextTheme != currentThemeName.value()) {
+        changedDependencies.push_back(UnistyleDependency::THEME);
+        changedDependencies.push_back(UnistyleDependency::THEMENAME);
+
+        state.setTheme(nextTheme);
+    }
+}
+
+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.");
+    helpers::assertThat(rt, args[0].isString(), "UnistylesRuntime.updateTheme expected first argument to be a string.");
+    helpers::assertThat(rt, args[1].isObject(), "UnistylesRuntime.updateTheme expected first argument to be a function.");
+
+    auto& registry = core::UnistylesRegistry::get();
+    auto themeName = args[0].asString(rt).utf8(rt);
+
+    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));
+
+    this->_onDependenciesChange({UnistyleDependency::THEME});
+
+    return jsi::Value::undefined();
+}
+
+void HybridUnistylesRuntime::setImmersiveMode(bool isEnabled) {
+    this->_nativePlatform.setImmersiveMode(isEnabled);
+};
+
+void HybridUnistylesRuntime::setRootViewBackgroundColor(double color) {
+    this->_nativePlatform.setRootViewBackgroundColor(color);
+}
+
+jsi::Value HybridUnistylesRuntime::createHybridStatusBar(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    if (this->_statusBar == nullptr) {
+        this->_statusBar = std::make_shared<HybridStatusBar>(_nativePlatform);
+    }
+
+    return this->_statusBar->toObject(rt);
+}
+
+jsi::Value HybridUnistylesRuntime::createHybridNavigationBar(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    if (this->_navigationBar == nullptr) {
+        this->_navigationBar = std::make_shared<HybridNavigationBar>(_nativePlatform);
+    }
+
+    return this->_navigationBar->toObject(rt);
+}
+
+UnistylesCxxMiniRuntime HybridUnistylesRuntime::getMiniRuntime() {
+    UnistylesNativeMiniRuntime nativeMiniRuntime = this->_nativePlatform.getMiniRuntime();
+    UnistylesCxxMiniRuntime cxxMiniRuntime{
+        this->getThemeName(),
+        this->getBreakpoint(),
+        nativeMiniRuntime.orientation,
+        this->getHasAdaptiveThemes(),
+        nativeMiniRuntime.colorScheme,
+        nativeMiniRuntime.screen,
+        nativeMiniRuntime.contentSizeCategory,
+        nativeMiniRuntime.insets,
+        nativeMiniRuntime.pixelRatio,
+        nativeMiniRuntime.fontScale,
+        nativeMiniRuntime.rtl,
+        nativeMiniRuntime.statusBar,
+        nativeMiniRuntime.navigationBar
+    };
+
+    return cxxMiniRuntime;
+}
+
+jsi::Value HybridUnistylesRuntime::getMiniRuntimeAsValue(jsi::Runtime& rt) {
+    auto miniRuntime = this->getMiniRuntime();
+    jsi::Object obj(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));
+    obj.setProperty(rt, "contentSizeCategory", JSIConverter<std::string>::toJSI(rt, miniRuntime.contentSizeCategory));
+    obj.setProperty(rt, "insets", JSIConverter<Insets>::toJSI(rt, miniRuntime.insets));
+    obj.setProperty(rt, "pixelRatio", JSIConverter<double>::toJSI(rt, miniRuntime.pixelRatio));
+    obj.setProperty(rt, "fontScale", JSIConverter<double>::toJSI(rt, miniRuntime.fontScale));
+    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));
+
+    return obj;
+}
+
+jsi::Runtime& HybridUnistylesRuntime::getRuntime() {
+    return *this->_rt;
+}
+
+void HybridUnistylesRuntime::registerPlatformListener(const std::function<void(std::vector<UnistyleDependency>)>& listener) {
+    this->_nativePlatform.registerPlatformListener(listener);
+    this->_onDependenciesChange = listener;
+}
+
+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

@@ -0,0 +1,72 @@
+#pragma once
+
+#include "HybridUnistylesRuntimeSpec.hpp"
+#include "HybridNativePlatformSpec.hpp"
+#include "Unistyles-Swift-Cxx-Umbrella.hpp"
+#include "UnistylesState.h"
+#include "HybridUnistylesStatusBarSpec.hpp"
+#include "HybridNavigationBar.h"
+#include "HybridStatusBar.h"
+#include "UnistylesRegistry.h"
+#include "Helpers.h"
+
+namespace margelo::nitro::unistyles {
+
+struct HybridUnistylesRuntime: public HybridUnistylesRuntimeSpec {
+    HybridUnistylesRuntime(Unistyles::HybridNativePlatformSpecCxx nativePlatform, jsi::Runtime& rt) : HybridObject(TAG), _nativePlatform{nativePlatform}, _rt{&rt} {}
+
+    jsi::Value updateTheme(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
+    jsi::Value createHybridStatusBar(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
+    jsi::Value createHybridNavigationBar(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
+
+    void loadHybridMethods() override {
+        HybridUnistylesRuntimeSpec::loadHybridMethods();
+
+        registerHybrids(this, [](Prototype& prototype) {
+            prototype.registerRawHybridMethod("updateTheme", 1, &HybridUnistylesRuntime::updateTheme);
+            prototype.registerRawHybridMethod("createHybridStatusBar", 0, &HybridUnistylesRuntime::createHybridStatusBar);
+            prototype.registerRawHybridMethod("createHybridNavigationBar", 0, &HybridUnistylesRuntime::createHybridNavigationBar);
+        });
+    };
+
+    ColorScheme getColorScheme() override;
+    bool getHasAdaptiveThemes() override;
+    bool getRtl() override;
+    Dimensions getScreen() override;
+    std::optional<std::string> getThemeName() override;
+    std::string getContentSizeCategory() override;
+    std::optional<std::string> getBreakpoint() override;
+    Insets getInsets() override;
+    Orientation getOrientation() override;
+    double getPixelRatio() override;
+    double getFontScale() override;
+    void registerPlatformListener(const std::function<void(std::vector<UnistyleDependency>)>& listener);
+
+    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);
+    jsi::Runtime& getRuntime();
+    void includeDependenciesForColorSchemeChange(std::vector<UnistyleDependency>& deps);
+    void calculateNewThemeAndDependencies(std::vector<UnistyleDependency>& deps);
+
+private:
+    jsi::Runtime* _rt;
+    std::shared_ptr<HybridNavigationBar> _navigationBar;
+    std::shared_ptr<HybridStatusBar> _statusBar;
+    Unistyles::HybridNativePlatformSpecCxx _nativePlatform;
+    std::function<void(std::vector<UnistyleDependency>)> _onDependenciesChange;
+};
+
+}