react-native-unistyles 2.9.2 → 3.0.0-alpha.1

package/cxx/core/StyleSheet.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include "Unistyle.h"
+#include "UnistyleWrapper.h"
+#include "Helpers.h"
+#include "Constants.h"
+
+namespace margelo::nitro::unistyles::core {
+
+using namespace facebook;
+
+enum class StyleSheetType {
+    Static,
+    Themable,
+    ThemableWithMiniRuntime
+};
+
+struct StyleSheet {
+    StyleSheet(int tag, StyleSheetType type, jsi::Object rawValue): tag{tag}, type{type}, rawValue{std::move(rawValue)} {};
+    
+    StyleSheet(const StyleSheet&) = delete;
+    StyleSheet(StyleSheet&& other) = delete;
+
+    int tag;
+    StyleSheetType type;
+    jsi::Object rawValue;
+    std::unordered_map<std::string, Unistyle::Shared> unistyles{};
+    std::vector<std::pair<std::string, std::string>> variants{};
+};
+
+}

package/cxx/core/StyleSheetRegistry.cpp

@@ -0,0 +1,45 @@
+#include "StyleSheetRegistry.h"
+#include "UnistylesRegistry.h"
+
+using namespace margelo::nitro::unistyles::core;
+using namespace facebook;
+
+std::shared_ptr<StyleSheet> StyleSheetRegistry::addStyleSheetFromValue(jsi::Runtime& rt, jsi::Object rawStyleSheet) {
+    static unsigned int tag = 0;
+
+    if (rawStyleSheet.isFunction(rt)) {
+        return this->addFromFunction(rt, ++tag, rawStyleSheet.asFunction(rt));
+    }
+
+    return this->addFromObject(rt, ++tag, std::move(rawStyleSheet));
+}
+
+std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromFunction(jsi::Runtime& rt, unsigned int tag, jsi::Function styleSheetFn) {
+    auto numberOfArgs = styleSheetFn.getProperty(rt, "length").getNumber();
+
+    helpers::assertThat(rt, numberOfArgs <= 2, "expected up to 2 arguments.");
+    
+    auto& registry = UnistylesRegistry::get();
+
+    // stylesheet is still static, remove the function wrapper
+    if (numberOfArgs == 0) {
+        auto staticStyleSheet = styleSheetFn.call(rt).asObject(rt);
+
+        return registry.addStyleSheet(tag, core::StyleSheetType::Static, std::move(staticStyleSheet));
+    }
+
+    // stylesheet depends only on theme
+    if (numberOfArgs == 1) {
+        return registry.addStyleSheet(tag, core::StyleSheetType::Themable, std::move(styleSheetFn));
+    }
+
+    // stylesheet depends on theme and mini runtime
+    return registry.addStyleSheet(tag, core::StyleSheetType::ThemableWithMiniRuntime, std::move(styleSheetFn));
+}
+
+std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromObject(jsi::Runtime& rt, unsigned int tag, jsi::Object rawStyleSheet) {
+    auto& registry = UnistylesRegistry::get();
+    
+    return registry.addStyleSheet(tag, core::StyleSheetType::Static, std::move(rawStyleSheet));
+}
+

package/cxx/core/StyleSheetRegistry.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include "StyleSheet.h"
+#include "Unistyle.h"
+#include "UnistylesState.h"
+
+namespace margelo::nitro::unistyles::core {
+
+using namespace facebook;
+
+struct StyleSheetRegistry {
+    StyleSheetRegistry() = default;
+    virtual ~StyleSheetRegistry() = default;
+
+    StyleSheetRegistry(const StyleSheetRegistry&) = delete;
+    StyleSheetRegistry(StyleSheetRegistry&&) = delete;
+
+    virtual std::shared_ptr<StyleSheet> addStyleSheetFromValue(jsi::Runtime& rt, jsi::Object rawStyleSheet);
+
+private:
+    virtual std::shared_ptr<StyleSheet> addFromFunction(jsi::Runtime& rt, unsigned int tag, jsi::Function styleSheetFn);
+    virtual std::shared_ptr<StyleSheet> addFromObject(jsi::Runtime& rt, unsigned int tag, jsi::Object rawStyleSheet);
+};
+
+}

package/cxx/core/Unistyle.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include "string"
+#include <jsi/jsi.h>
+#include <folly/dynamic.h>
+#include "Unistyles-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::unistyles::core {
+
+using namespace facebook;
+
+enum class UnistyleType {
+    Object,
+    DynamicFunction
+};
+
+struct DynamicFunctionMetadata {
+    size_t count;
+    std::vector<folly::dynamic> arguments;
+};
+
+struct Unistyle {
+    using Shared = std::shared_ptr<Unistyle>;
+
+    Unistyle(UnistyleType type, std::string styleKey, jsi::Object& rawObject)
+        : styleKey{styleKey}, type{type}, rawValue{std::move(rawObject)} {}
+    virtual ~Unistyle() = default;
+
+    Unistyle(const Unistyle&) = delete;
+    Unistyle(Unistyle&& other) = delete;
+
+    UnistyleType type;
+    std::string styleKey;
+    jsi::Object rawValue;
+    std::optional<jsi::Object> parsedStyle;
+    std::vector<UnistyleDependency> dependencies{};
+
+    inline void addDependency(UnistyleDependency dependency) {
+        // we can't add dependencies if unistyle is sealed
+        if (this->_isSealed) {
+            return;
+        }
+
+        auto it = std::find(this->dependencies.begin(), this->dependencies.end(), dependency);
+
+        if (it == this->dependencies.end()) {
+            this->dependencies.push_back(dependency);
+        }
+    }
+
+    inline bool dependsOn(UnistyleDependency dependency) {
+        return std::find(this->dependencies.begin(), this->dependencies.end(), dependency) != this->dependencies.end();
+    }
+
+    inline void seal() {
+        this->_isSealed = true;
+    }
+
+private:
+    bool _isSealed = false;
+};
+
+struct UnistyleDynamicFunction: public Unistyle {
+    // dynamic function must have 4 different value types
+    // rawValue <- original user function
+    // proxiedFunction <- host function that is a wrapper for user's original function
+    // unprocessedValue <- object generated after calling proxy and user's original function
+    // parsedStyle <- parsed with Unistyle's parser
+
+    UnistyleDynamicFunction(UnistyleType type, std::string styleKey, jsi::Object& rawObject)
+        : Unistyle(type, styleKey, rawObject) {}
+
+    UnistyleDynamicFunction(const UnistyleDynamicFunction&) = delete;
+    UnistyleDynamicFunction(UnistyleDynamicFunction&& other) = delete;
+
+    std::optional<jsi::Object> unprocessedValue;
+    std::optional<jsi::Function> proxiedFunction = std::nullopt;
+    std::optional<DynamicFunctionMetadata> dynamicFunctionMetadata = std::nullopt;
+};
+
+}

package/cxx/core/UnistyleWrapper.cpp

@@ -0,0 +1,5 @@
+#include "UnistyleWrapper.h"
+
+using namespace margelo::nitro::unistyles;
+
+core::UnistyleWrapper::~UnistyleWrapper() = default;

package/cxx/core/UnistyleWrapper.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include "Unistyle.h"
+#include "Helpers.h"
+#include "Constants.h"
+
+namespace margelo::nitro::unistyles::core {
+
+struct UnistyleWrapper: public jsi::NativeState {
+    explicit UnistyleWrapper(Unistyle::Shared unistyle)
+        : unistyle(std::move(unistyle)) {}
+
+    ~UnistyleWrapper() override;
+
+    Unistyle::Shared unistyle;
+};
+
+inline static Unistyle::Shared unistyleFromValue(jsi::Runtime& rt, const jsi::Value& value) {
+    if (value.isNull()) {
+        return nullptr;
+    }
+
+    return value.getObject(rt).getNativeState<UnistyleWrapper>(rt)->unistyle;
+}
+
+inline static jsi::Value valueFromUnistyle(jsi::Runtime& rt, Unistyle::Shared unistyle) {
+    auto wrappedUnistyle = std::make_shared<UnistyleWrapper>(unistyle);
+    
+    if (unistyle->type == UnistyleType::Object) {
+        jsi::Object obj = jsi::Object(rt);
+        
+        obj.setNativeState(rt, std::move(wrappedUnistyle));
+        helpers::defineHiddenProperty(rt, obj, helpers::UNISTYLES_ID.c_str(), unistyle->styleKey);
+        
+        helpers::mergeJSIObjects(rt, obj, unistyle->parsedStyle.value());
+        
+        return obj;
+    }
+    
+    auto unistyleFn = std::dynamic_pointer_cast<UnistyleDynamicFunction>(unistyle);
+    auto hostFn = jsi::Value(rt, unistyleFn->proxiedFunction.value()).asObject(rt).asFunction(rt);
+
+    hostFn.setNativeState(rt, std::move(wrappedUnistyle));
+    hostFn.setProperty(rt, helpers::UNISTYLES_ID.c_str(), unistyleFn->styleKey);
+    
+    return std::move(hostFn);
+}
+
+}

package/cxx/core/UnistylesCommitHook.cpp

@@ -0,0 +1,53 @@
+#include "UnistylesCommitHook.h"
+
+using namespace margelo::nitro::unistyles;
+using namespace facebook::react;
+
+core::UnistylesCommitHook::UnistylesCommitHook(UIManager& uiManager, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
+    : _unistylesRuntime{unistylesRuntime} {
+        uiManager.registerCommitHook(*this);
+    };
+
+core::UnistylesCommitHook::~UnistylesCommitHook() noexcept {}
+
+void core::UnistylesCommitHook::commitHookWasRegistered(const UIManager &uiManager) noexcept {}
+void core::UnistylesCommitHook::commitHookWasUnregistered(const UIManager &uiManager) noexcept {}
+
+RootShadowNode::Unshared core::UnistylesCommitHook::shadowTreeWillCommit(
+    const ShadowTree &shadowTree,
+    const RootShadowNode::Shared &oldRootShadowNode,
+    const RootShadowNode::Unshared &newRootShadowNode
+) noexcept {
+    RootShadowNode::Unshared rootNode = newRootShadowNode;
+    auto unistylesRootNode = std::reinterpret_pointer_cast<core::UnistylesCommitShadowNode>(newRootShadowNode);
+    
+    // skip only unistyles commits
+    if (unistylesRootNode->hasUnistylesCommitTrait()) {
+        unistylesRootNode->removeUnistylesCommitTrait();
+        
+        return newRootShadowNode;
+    }
+
+    auto shadowLeafUpdates = this->getUnistylesUpdates();
+    
+    if (shadowLeafUpdates.size() == 0) {
+        return newRootShadowNode;
+    }
+    
+    auto affectedNodes = shadow::ShadowTreeManager::findAffectedNodes(*rootNode, shadowLeafUpdates);
+
+    return std::static_pointer_cast<RootShadowNode>(shadow::ShadowTreeManager::cloneShadowTree(
+        this->_unistylesRuntime->getRuntime(),
+        *rootNode,
+        shadowLeafUpdates,
+        affectedNodes
+    ));
+}
+
+shadow::ShadowLeafUpdates core::UnistylesCommitHook::getUnistylesUpdates() {
+    auto& registry = core::UnistylesRegistry::get();
+    auto parser = parser::Parser(this->_unistylesRuntime);
+    auto dependencyMap = registry.buildDependencyMap();
+    
+    return parser.dependencyMapToShadowLeafUpdates(dependencyMap);
+}

package/cxx/core/UnistylesCommitHook.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <react/renderer/uimanager/UIManager.h>
+#include <react/renderer/uimanager/UIManagerCommitHook.h>
+#include "HybridUnistylesRuntime.h"
+#include "Parser.h"
+#include "ShadowTreeManager.h"
+
+namespace margelo::nitro::unistyles::core {
+
+using namespace facebook::react;
+
+struct UnistylesCommitHook : public UIManagerCommitHook {
+    UnistylesCommitHook(UIManager& uiManager, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime);
+    ~UnistylesCommitHook() noexcept override;
+
+    void commitHookWasRegistered(const UIManager &uiManager) noexcept override;
+    void commitHookWasUnregistered(const UIManager &uiManager) noexcept override;
+    RootShadowNode::Unshared shadowTreeWillCommit(const ShadowTree &shadowTree, const RootShadowNode::Shared &oldRootShadowNode, const RootShadowNode::Unshared &newRootShadowNode) noexcept override;
+    
+    shadow::ShadowLeafUpdates getUnistylesUpdates();
+    
+private:
+    std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+};
+
+}

package/cxx/core/UnistylesCommitShadowNode.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <react/renderer/core/ShadowNode.h>
+
+namespace margelo::nitro::unistyles::core {
+
+// used to distinguish Unistyles commits
+// React Native uses 0-10
+// Reanimated uses 27-28
+constexpr shadow::ShadowNodeTraits::Trait UnistylesCommitTrait{1 << 30};
+
+struct UnistylesCommitShadowNode: public shadow::ShadowNode {
+    inline void addUnistylesCommitTrait() {
+        traits_.set(UnistylesCommitTrait);
+    }
+    
+    inline void removeUnistylesCommitTrait() {
+        traits_.unset(UnistylesCommitTrait);
+    }
+    
+    inline bool hasUnistylesCommitTrait() {
+        return traits_.check(UnistylesCommitTrait);
+    }
+};
+
+}

package/cxx/core/UnistylesRegistry.cpp

@@ -0,0 +1,176 @@
+#include "UnistylesRegistry.h"
+#include "UnistylesState.h"
+
+using namespace margelo::nitro::unistyles;
+using namespace facebook;
+using namespace facebook::react;
+
+using DependencyMap = std::unordered_map<
+    std::shared_ptr<core::StyleSheet>,
+    std::unordered_map<const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>>
+>;
+
+void core::UnistylesRegistry::registerTheme(jsi::Runtime& rt, std::string name, jsi::Object&& theme) {
+    auto& state = this->getState(rt);
+
+    state._jsThemes.emplace(name, jsi::WeakObject(rt, 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);
+
+    state._sortedBreakpointPairs = std::move(sortedBreakpoints);
+}
+
+void core::UnistylesRegistry::setPrefersAdaptiveThemes(jsi::Runtime& rt, bool prefersAdaptiveThemes) {
+    auto& state = this->getState(rt);
+
+    state._prefersAdaptiveThemes = prefersAdaptiveThemes;
+}
+
+void core::UnistylesRegistry::setInitialThemeName(jsi::Runtime& rt, std::string themeName) {
+    auto& state = this->getState(rt);
+
+    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 {}.");
+
+    return it->second;
+}
+
+void core::UnistylesRegistry::createState(jsi::Runtime& rt) {
+    auto it = this->_states.find(&rt);
+
+    // remove old state, so we can swap it with new config
+    // during live reload
+    if (it != this->_states.end()) {
+        this->_states.extract(&rt);
+    }
+
+    this->_states.emplace(
+        std::piecewise_construct,
+        std::forward_as_tuple(&rt),
+        std::forward_as_tuple(rt)
+    );
+}
+
+void core::UnistylesRegistry::updateTheme(jsi::Runtime& rt, std::string& themeName, jsi::Function&& callback) {
+    auto& state = this->getState(rt);
+    auto it = state._jsThemes.find(themeName);
+    
+    helpers::assertThat(rt, it != state._jsThemes.end(), "you're trying to update theme '" + themeName + "' but it wasn't registered.");
+    
+    auto currentThemeValue = it->second.lock(rt);
+    
+    helpers::assertThat(rt, currentThemeValue.isObject(), "unable to update your theme from C++. It was already garbage collected.");
+    
+    auto result = callback.call(rt, currentThemeValue.asObject(rt));
+    
+    helpers::assertThat(rt, result.isObject(), "returned theme is not an object. Please check your updateTheme function.");
+
+    it->second = jsi::WeakObject(rt, result.asObject(rt));
+}
+
+void core::UnistylesRegistry::linkShadowNodeWithUnistyle(const ShadowNodeFamily* shadowNodeFamily, const core::Unistyle::Shared unistyle) {
+    if (!this->_shadowRegistry.contains(shadowNodeFamily)) {
+        this->_shadowRegistry[shadowNodeFamily] = {};
+    }
+    
+    this->_shadowRegistry[shadowNodeFamily].emplace_back(unistyle);
+}
+
+void core::UnistylesRegistry::unlinkShadowNodeWithUnistyle(const ShadowNodeFamily* shadowNodeFamily, const core::Unistyle::Shared unistyle) {
+    auto& unistylesVec = this->_shadowRegistry[shadowNodeFamily];
+    auto it = std::find(unistylesVec.begin(), unistylesVec.end(), unistyle);
+    
+    if (it != unistylesVec.end()) {
+        this->_shadowRegistry[shadowNodeFamily].erase(it);
+    }
+}
+
+std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::addStyleSheet(int tag, core::StyleSheetType type, jsi::Object&& rawValue) {
+    this->_styleSheetRegistry.emplace_back(std::make_shared<core::StyleSheet>(tag, type, std::move(rawValue)));
+
+    return this->_styleSheetRegistry.back();
+}
+
+std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::getStyleSheetById(int tag) {
+    auto it = std::find_if(
+        this->_styleSheetRegistry.begin(),
+        this->_styleSheetRegistry.end(),
+        [tag](std::shared_ptr<StyleSheet> styleSheet){
+            return styleSheet->tag == tag;
+        }
+    );
+    
+    if (it == this->_styleSheetRegistry.cend()) {
+        throw std::runtime_error("stylesheet with tag: " + std::to_string(tag) + " cannot be found.");
+    }
+    
+    return *it;
+}
+    
+DependencyMap core::UnistylesRegistry::buildDependencyMap(std::vector<UnistyleDependency>& deps) {
+    DependencyMap dependencyMap;
+ 
+    for (const auto& styleSheet : this->_styleSheetRegistry) {
+        for (const auto& [_, unistyle] : styleSheet->unistyles) {
+            // check if in the given stylesheet we have unistyle
+            // that depends on something affected
+            bool hasAnyOfDependencies = std::any_of(
+                unistyle->dependencies.begin(),
+                unistyle->dependencies.end(),
+                [&deps](UnistyleDependency dep) {
+                    return std::find(deps.begin(), deps.end(), dep) != deps.end();
+                }
+            );
+            
+            if (!hasAnyOfDependencies) {
+                continue;
+            }
+            
+            // if so, we need to find shadow family too
+            for (const auto& pair : this->_shadowRegistry) {
+                const auto& [family, unistyles] = pair;
+                
+                for (const auto& shadowUnistyle : unistyles) {
+                    if (unistyle != shadowUnistyle) {
+                        continue;
+                    }
+
+                    dependencyMap[styleSheet][family].push_back(shadowUnistyle);
+                }
+            }
+        }
+    }
+
+    return dependencyMap;
+}
+
+DependencyMap core::UnistylesRegistry::buildDependencyMap() {
+    DependencyMap dependencyMap;
+ 
+    for (const auto& styleSheet : this->_styleSheetRegistry) {
+        for (const auto& [_, unistyle] : styleSheet->unistyles) {
+            for (const auto& pair : this->_shadowRegistry) {
+                const auto& [family, unistyles] = pair;
+                
+                for (const auto& shadowUnistyle : unistyles) {
+                    if (unistyle != shadowUnistyle) {
+                        continue;
+                    }
+
+                    // make sure to use base Unistyle class
+                    dependencyMap[styleSheet][family].push_back(shadowUnistyle);
+                }
+            }
+        }
+    }
+
+    return dependencyMap;
+}

package/cxx/core/UnistylesRegistry.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <react/renderer/uimanager/UIManager.h>
+#include <unordered_map>
+#include <unordered_set>
+#include "Breakpoints.h"
+#include "StyleSheetRegistry.h"
+#include "StyleSheet.h"
+#include "Unistyle.h"
+
+namespace margelo::nitro::unistyles::core {
+
+struct UnistylesState;
+
+using namespace facebook;
+using namespace facebook::react;
+
+using DependencyMap = std::unordered_map<
+    std::shared_ptr<core::StyleSheet>,
+    std::unordered_map<const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>>
+>;
+
+struct UnistylesRegistry: public StyleSheetRegistry {
+    static UnistylesRegistry& get();
+
+    UnistylesRegistry(const UnistylesRegistry&) = delete;
+    UnistylesRegistry(const UnistylesRegistry&&) = delete;
+
+    void registerTheme(jsi::Runtime& rt, std::string name, jsi::Object&& 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 updateTheme(jsi::Runtime& rt, std::string& themeName, jsi::Function&& callback);
+
+    UnistylesState& getState(jsi::Runtime& rt);
+    void createState(jsi::Runtime& rt);
+    void linkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared);
+    void unlinkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared);
+    std::shared_ptr<core::StyleSheet> addStyleSheet(int tag, core::StyleSheetType type, jsi::Object&& rawValue);
+    std::shared_ptr<core::StyleSheet> getStyleSheetById(int tag);
+    DependencyMap buildDependencyMap(std::vector<UnistyleDependency>& deps);
+    DependencyMap buildDependencyMap();
+
+private:
+    UnistylesRegistry() = default;
+
+    std::unordered_map<jsi::Runtime*, UnistylesState> _states{};
+    std::vector<std::shared_ptr<core::StyleSheet>> _styleSheetRegistry{};
+    std::unordered_map<const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>> _shadowRegistry{};
+};
+
+UnistylesRegistry& UnistylesRegistry::get() {
+    static UnistylesRegistry cache;
+
+    return cache;
+}
+
+}

package/cxx/core/UnistylesState.cpp

@@ -0,0 +1,95 @@
+#include "UnistylesState.h"
+#include "UnistylesRegistry.h"
+
+using namespace margelo::nitro::unistyles;
+
+bool core::UnistylesState::hasAdaptiveThemes() {
+    if (!this->_prefersAdaptiveThemes.has_value() || !this->_prefersAdaptiveThemes.value()) {
+        return false;
+    }
+
+    return helpers::vecContainsKeys(this->_registeredThemeNames, {"light", "dark"});
+}
+
+void core::UnistylesState::setTheme(std::string themeName) {
+    helpers::assertThat(*_rt, helpers::vecContainsKeys(this->_registeredThemeNames, {themeName}), "You're trying to set theme to: '" + std::string(themeName) + "', but it wasn't registered.");
+
+    if (themeName != this->_currentThemeName) {
+        this->_currentThemeName = themeName;
+    }
+}
+
+std::optional<std::string>& core::UnistylesState::getCurrentThemeName() {
+    return this->_currentThemeName;
+}
+
+jsi::Object core::UnistylesState::getJSTheme() {
+    auto hasSomeThemes = _registeredThemeNames.size() > 0;
+
+    // return empty object, if user didn't register any themes
+    if (!hasSomeThemes) {
+        return jsi::Object(*_rt);
+    }
+
+    helpers::assertThat(*_rt, _currentThemeName.has_value(), "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(), "you're trying to get theme '" + _currentThemeName.value() + "', but it was not registered. Did you forget to register it with StyleSheet.configure?");
+
+    auto maybeTheme = it->second.lock(*_rt);
+
+    helpers::assertThat(*_rt, maybeTheme.isObject(), "unable to retrieve your theme from C++ as it has already been garbage collected, likely due to multiple hot reloads. Please live reload the app.");
+
+    return maybeTheme.asObject(*_rt);
+}
+
+void core::UnistylesState::computeCurrentBreakpoint(int screenWidth) {
+    this->_currentBreakpointName = helpers::getBreakpointFromScreenWidth(
+        screenWidth,
+        this->_sortedBreakpointPairs
+    );
+}
+
+bool core::UnistylesState::hasTheme(std::string themeName) {
+    return helpers::vecContainsKeys(this->_registeredThemeNames, {themeName});
+}
+
+bool core::UnistylesState::hasInitialTheme() {
+    return this->_initialThemeName.has_value();
+}
+
+std::vector<std::string> core::UnistylesState::getRegisteredThemeNames() {
+    return std::vector<std::string>(this->_registeredThemeNames);
+}
+
+std::vector<std::pair<std::string, double>> core::UnistylesState::getSortedBreakpointPairs() {
+    return std::vector<std::pair<std::string, double>>(this->_sortedBreakpointPairs);
+}
+
+std::optional<std::string> core::UnistylesState::getInitialTheme() {
+    return this->_initialThemeName;
+}
+
+std::optional<std::string> core::UnistylesState::getCurrentBreakpointName() {
+    return this->_currentBreakpointName;
+}
+
+bool core::UnistylesState::getPrefersAdaptiveThemes() {
+    return this->_prefersAdaptiveThemes.has_value() && this->_prefersAdaptiveThemes.value();
+}
+
+void core::UnistylesState::registerProcessColorFunction(jsi::Function&& fn) {
+    this->_processColorFn = std::make_shared<jsi::Function>(std::move(fn));
+}
+
+int core::UnistylesState::parseColor(jsi::Value& maybeColor) {
+    if (!maybeColor.isString()) {
+        return 0;
+    }
+    
+    // we must convert it to uint32_t first, otherwise color will be broken
+    uint32_t color = this->_processColorFn.get()->call(*_rt, maybeColor.asString(*_rt)).asNumber();
+
+    return color;
+}