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

package/cxx/core/UnistylesRegistry.cpp

@@ -0,0 +1,162 @@
+#include "UnistylesRegistry.h"
+#include "UnistylesState.h"
+
+using namespace margelo::nitro::unistyles;
+using namespace facebook;
+using namespace facebook::react;
+
+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(), "Unistyles: You're trying to update theme '" + themeName + "' but it wasn't registered.");
+
+    auto currentThemeValue = it->second.lock(rt);
+
+    helpers::assertThat(rt, currentThemeValue.isObject(), "Unistyles: 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(), "Unistyles: 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,
+    Variants& variants,
+    std::vector<folly::dynamic>& arguments
+) {
+    if (!this->_shadowRegistry.contains(shadowNodeFamily)) {
+        this->_shadowRegistry[shadowNodeFamily] = {};
+    }
+
+    this->_shadowRegistry[shadowNodeFamily].emplace_back(std::make_shared<UnistyleData>(unistyle, variants, arguments));
+}
+
+void core::UnistylesRegistry::unlinkShadowNodeWithUnistyle(const ShadowNodeFamily* shadowNodeFamily, const core::Unistyle::Shared unistyle) {
+    auto& unistylesVec = this->_shadowRegistry[shadowNodeFamily];
+    auto it = std::find_if(unistylesVec.begin(), unistylesVec.end(), [unistyle](std::shared_ptr<UnistyleData> unistyleData){
+        return unistyleData->unistyle == unistyle;
+    });
+
+    if (it != unistylesVec.end()) {
+        this->_shadowRegistry[shadowNodeFamily].erase(it);
+    }
+}
+
+std::shared_ptr<core::StyleSheet> core::UnistylesRegistry::addStyleSheet(jsi::Runtime& rt, int unid, core::StyleSheetType type, jsi::Object&& rawValue) {
+    this->_styleSheetRegistry[&rt][unid] = std::make_shared<core::StyleSheet>(unid, type, std::move(rawValue));
+
+    return this->_styleSheetRegistry[&rt][unid];
+}
+
+core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt, std::vector<UnistyleDependency>& deps) {
+    DependencyMap dependencyMap;
+    std::set<UnistyleDependency> uniqueDependencies(deps.begin(), deps.end());
+
+    for (const auto& [_, styleSheet] : this->_styleSheetRegistry[&rt]) {
+        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(),
+                [&uniqueDependencies](UnistyleDependency dep) {
+                    return std::find(uniqueDependencies.begin(), uniqueDependencies.end(), dep) != uniqueDependencies.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& unistyleData : unistyles) {
+                    if (unistyle != unistyleData->unistyle) {
+                        continue;
+                    }
+
+                    dependencyMap[styleSheet][family].emplace_back(unistyleData);
+                }
+            }
+        }
+    }
+
+    return dependencyMap;
+}
+
+core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt) {
+    DependencyMap dependencyMap;
+
+    for (const auto& [_, styleSheet] : this->_styleSheetRegistry[&rt]) {
+        for (const auto& [_, unistyle] : styleSheet->unistyles) {
+            for (const auto& pair : this->_shadowRegistry) {
+                const auto& [family, unistyles] = pair;
+
+                for (const auto& unistyleData : unistyles) {
+                    if (unistyle != unistyleData->unistyle) {
+                        continue;
+                    }
+
+                    dependencyMap[styleSheet][family].emplace_back(unistyleData);
+                }
+            }
+        }
+    }
+
+    return dependencyMap;
+}

package/cxx/core/UnistylesRegistry.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "set"
+#include <jsi/jsi.h>
+#include <folly/dynamic.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"
+#include "UnistyleData.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<std::shared_ptr<UnistyleData>>>
+>;
+
+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, Variants& variants, std::vector<folly::dynamic>&);
+    void unlinkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared);
+    std::shared_ptr<core::StyleSheet> addStyleSheet(jsi::Runtime& rt, int tag, core::StyleSheetType type, jsi::Object&& rawValue);
+    DependencyMap buildDependencyMap(jsi::Runtime& rt, std::vector<UnistyleDependency>& deps);
+    DependencyMap buildDependencyMap(jsi::Runtime& rt);
+
+private:
+    UnistylesRegistry() = default;
+
+    std::unordered_map<jsi::Runtime*, UnistylesState> _states{};
+    std::unordered_map<jsi::Runtime*, std::unordered_map<int, std::shared_ptr<core::StyleSheet>>> _styleSheetRegistry{};
+    std::unordered_map<const ShadowNodeFamily*, std::vector<std::shared_ptr<UnistyleData>>> _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}), "Unistyles: 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(), "Unistyles: One of your stylesheets is trying to get the theme, but no theme has been selected yet. Did you forget to select an initial theme?");
+
+    auto it = this->_jsThemes.find(_currentThemeName.value());
+
+    helpers::assertThat(*_rt, it != this->_jsThemes.end(), "Unistyles: You're trying to get theme '" + _currentThemeName.value() + "', but it was not registered. Did you forget to register it with StyleSheet.configure?");
+
+    auto maybeTheme = it->second.lock(*_rt);
+
+    helpers::assertThat(*_rt, maybeTheme.isObject(), "Unistyles: 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;
+}

package/cxx/core/UnistylesState.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <string>
+#include <optional>
+#include <jsi/jsi.h>
+#include <vector>
+#include "Helpers.h"
+
+namespace margelo::nitro::unistyles::core {
+
+struct UnistylesRegistry;
+
+using namespace facebook;
+
+struct UnistylesState {
+    UnistylesState(jsi::Runtime& rt): _rt{&rt} {}
+    UnistylesState(const UnistylesState&) = delete;
+    UnistylesState(const UnistylesState&&) = delete;
+
+    bool hasAdaptiveThemes();
+    bool hasInitialTheme();
+    bool getPrefersAdaptiveThemes();
+    void setTheme(std::string themeName);
+    bool hasTheme(std::string themeName);
+    std::optional<std::string>& getCurrentThemeName();
+    std::vector<std::string> getRegisteredThemeNames();
+    std::optional<std::string> getInitialTheme();
+    std::optional<std::string> getCurrentBreakpointName();
+    std::vector<std::pair<std::string, double>> getSortedBreakpointPairs();
+
+    jsi::Object getJSTheme();
+    int parseColor(jsi::Value& color);
+    void computeCurrentBreakpoint(int screenWidth);
+    void registerProcessColorFunction(jsi::Function&& fn);
+
+private:
+    jsi::Runtime* _rt;
+    std::unordered_map<std::string, jsi::WeakObject> _jsThemes{};
+    std::optional<bool> _prefersAdaptiveThemes = std::nullopt;
+    std::optional<std::string> _initialThemeName = std::nullopt;
+    std::optional<std::string> _currentBreakpointName = std::nullopt;
+    std::vector<std::pair<std::string, double>> _sortedBreakpointPairs{};
+    std::vector<std::string> _registeredThemeNames{};
+    std::optional<std::string> _currentThemeName = std::nullopt;
+    std::shared_ptr<jsi::Function> _processColorFn;
+
+    friend class UnistylesRegistry;
+};
+
+}

package/cxx/hybridObjects/HybridNavigationBar.cpp

@@ -0,0 +1,17 @@
+#include "HybridNavigationBar.h"
+
+void HybridNavigationBar::setBackgroundColor(double color) {
+    this->_nativePlatform.setNavigationBarBackgroundColor(color);
+};
+
+void HybridNavigationBar::setHidden(bool isHidden) {
+    this->_nativePlatform.setNavigationBarHidden(isHidden);
+};
+
+double HybridNavigationBar::getWidth() {
+    return this->_nativePlatform.getNavigationBarDimensions().width;
+}
+
+double HybridNavigationBar::getHeight() {
+    return this->_nativePlatform.getNavigationBarDimensions().height;
+}

package/cxx/hybridObjects/HybridNavigationBar.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "HybridUnistylesNavigationBarSpec.hpp"
+#include "Unistyles-Swift-Cxx-Umbrella.hpp"
+#include <optional>
+
+using namespace margelo::nitro::unistyles;
+
+struct HybridNavigationBar: public HybridUnistylesNavigationBarSpec {
+    HybridNavigationBar(Unistyles::HybridNativePlatformSpecCxx nativePlatform): HybridObject(TAG), _nativePlatform{nativePlatform} {}
+    
+    void setBackgroundColor(double color) override;
+    void setHidden(bool isHidden) override;
+    double getWidth() override;
+    double getHeight() override;
+    
+private:
+    Unistyles::HybridNativePlatformSpecCxx _nativePlatform;
+};

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -0,0 +1,33 @@
+#include "HybridShadowRegistry.h"
+
+using namespace margelo::nitro::unistyles;
+using namespace facebook::react;
+
+jsi::Value HybridShadowRegistry::link(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    helpers::assertThat(rt, count == 4, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected 4 arguments.");
+    
+    ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
+    core::Unistyle::Shared unistyleWrapper = core::unistyleFromValue(rt, args[1]);
+    core::Variants variants = helpers::variantsToPairs(rt, args[2].asObject(rt));
+    auto rawArguments = args[3].asObject(rt).asArray(rt);
+    std::vector<folly::dynamic> arguments = helpers::parseDynamicFunctionArguments(rt, rawArguments);
+    
+    auto& registry = core::UnistylesRegistry::get();
+    
+    registry.linkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper, variants, arguments);
+    
+    return jsi::Value::undefined();
+}
+
+jsi::Value HybridShadowRegistry::unlink(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    helpers::assertThat(rt, count == 2, "Unistyles: Invalid babel transform 'ShadowRegistry unlink' expected 2 arguments.");
+    
+    ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
+    core::Unistyle::Shared unistyleWrapper = core::unistyleFromValue(rt, args[1]);
+    
+    auto& registry = core::UnistylesRegistry::get();
+
+    registry.unlinkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper);
+    
+    return jsi::Value::undefined();
+}

package/cxx/hybridObjects/HybridShadowRegistry.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "HybridUnistylesShadowRegistrySpec.hpp"
+#include <react/renderer/uimanager/primitives.h>
+#include "UnistyleWrapper.h"
+#include "UnistylesState.h"
+#include "UnistylesRegistry.h"
+
+namespace margelo::nitro::unistyles {
+
+struct HybridShadowRegistry: public HybridUnistylesShadowRegistrySpec {
+    HybridShadowRegistry(): HybridObject(TAG) {}
+    
+    jsi::Value link(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
+    jsi::Value unlink(jsi::Runtime& rt,
+                            const jsi::Value& thisValue,
+                            const jsi::Value* args,
+                            size_t count);
+
+    void loadHybridMethods() override {
+        HybridUnistylesShadowRegistrySpec::loadHybridMethods();
+
+        registerHybrids(this, [](Prototype& prototype) {
+            prototype.registerRawHybridMethod("link", 2, &HybridShadowRegistry::link);
+            prototype.registerRawHybridMethod("unlink", 2, &HybridShadowRegistry::unlink);
+        });
+    };
+};
+
+}

package/cxx/hybridObjects/HybridStatusBar.cpp

@@ -0,0 +1,17 @@
+#include "HybridStatusBar.h"
+
+void HybridStatusBar::setBackgroundColor(double color) {
+    this->_nativePlatform.setStatusBarBackgroundColor(color);
+}
+
+double HybridStatusBar::getWidth() {
+    return this->_nativePlatform.getStatusBarDimensions().width;
+}
+
+double HybridStatusBar::getHeight() {
+    return this->_nativePlatform.getStatusBarDimensions().height;
+}
+
+void HybridStatusBar::setHidden(bool isHidden) {
+    return this->_nativePlatform.setStatusBarHidden(isHidden);
+}

package/cxx/hybridObjects/HybridStatusBar.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "HybridUnistylesStatusBarSpec.hpp"
+#include "Unistyles-Swift-Cxx-Umbrella.hpp"
+#include <optional>
+
+using namespace margelo::nitro::unistyles;
+
+struct HybridStatusBar: public HybridUnistylesStatusBarSpec {
+    HybridStatusBar(Unistyles::HybridNativePlatformSpecCxx nativePlatform): HybridObject(TAG), _nativePlatform{nativePlatform} {}
+ 
+    void setBackgroundColor(double color) override;
+    double getWidth() override;
+    double getHeight() override;
+    void setHidden(bool isHidden) override;
+    
+private:
+    Unistyles::HybridNativePlatformSpecCxx _nativePlatform;
+};