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

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,26 @@
+#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) {
+    ShadowNode::Shared shadowNodeWrapper = shadowNodeFromValue(rt, args[0]);
+    core::Unistyle::Shared unistyleWrapper = core::unistyleFromValue(rt, args[1]);
+    
+    auto& registry = core::UnistylesRegistry::get();
+    
+    registry.linkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper);
+    
+    return jsi::Value::undefined();
+}
+
+jsi::Value HybridShadowRegistry::unlink(jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *args, size_t count) {
+    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;
+};

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -0,0 +1,245 @@
+#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) {
+    helpers::assertThat(rt, arguments[0].isObject(), "expected to be called with object or function.");
+
+    auto thisStyleSheet = thisVal.asObject(rt);
+    auto& registry = core::UnistylesRegistry::get();
+
+    // this might happen only when hot reloading
+    if (this->__unid != -1) {
+        auto registeredStyleSheet = registry.getStyleSheetById(this->__unid);
+        auto style = std::make_shared<core::HostStyle>(registeredStyleSheet, this->_unistylesRuntime);
+        auto styleHostObject = jsi::Object::createFromHostObject(rt, style);
+
+        return styleHostObject;
+    }
+
+    jsi::Object rawStyleSheet = arguments[0].asObject(rt);
+    auto registeredStyleSheet = registry.addStyleSheetFromValue(rt, std::move(rawStyleSheet));
+
+    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, arguments[0].isObject(), "expected to be called with object.");
+
+    // create new state
+    auto config = arguments[0].asObject(rt);
+    auto& registry = core::UnistylesRegistry::get();
+
+    registry.createState(rt);
+
+    helpers::enumerateJSIObject(rt, config, [&](const std::string& propertyName, jsi::Value& propertyValue){
+        if (propertyName == "settings") {
+            helpers::assertThat(rt, propertyValue.isObject(), "settings must be an object.");
+
+            return this->parseSettings(rt, propertyValue.asObject(rt));
+        }
+
+        if (propertyName == "breakpoints") {
+            helpers::assertThat(rt, propertyValue.isObject(), "breakpoints must be an object.");
+
+            return this->parseBreakpoints(rt, propertyValue.asObject(rt));
+        }
+
+        if (propertyName == "themes") {
+            helpers::assertThat(rt, propertyValue.isObject(), "themes must be an object.");
+
+            return this->parseThemes(rt, propertyValue.asObject(rt));
+        }
+
+        helpers::assertThat(rt, false, "received unexpected key: '" + std::string(propertyName) + "'.");
+    });
+
+    verifyAndSelectTheme(rt);
+    loadExternalMethods(thisVal, rt);
+    registerCommitHook(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(), "adaptiveThemes configuration 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), "initialTheme configuration must be either a string or a function.");
+
+                auto result = propertyValue.asObject(rt).asFunction(rt).call(rt);
+
+                helpers::assertThat(rt, result.isString(), "initialTheme resolved from function is not a string. Please check your initialTheme function.");
+
+                return registry.setInitialThemeName(rt, result.asString(rt).utf8(rt));
+            }
+
+            helpers::assertThat(rt, propertyValue.isString(), "initialTheme configuration must be either a string or a function.");
+
+            registry.setInitialThemeName(rt, propertyValue.asString(rt).utf8(rt));
+
+            return;
+        }
+
+        helpers::assertThat(rt, false, "settings received unexpected key: '" + std::string(propertyName) + "'");
+    });
+}
+
+void HybridStyleSheet::parseBreakpoints(jsi::Runtime &rt, jsi::Object breakpoints){
+    helpers::Breakpoints sortedBreakpoints = helpers::jsiBreakpointsToVecPairs(rt, std::move(breakpoints));
+
+    helpers::assertThat(rt, sortedBreakpoints.size() > 0, "registered breakpoints can't be empty.");
+    helpers::assertThat(rt, sortedBreakpoints.front().second == 0, "first breakpoint must start from 0.");
+
+    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(), "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, "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, "you're trying to set initial theme and enable adaptiveThemes, but these options are mutually exclusive.");
+    }
+
+    // user only selected initial theme
+    // validate if following theme exist
+    std::string selectedTheme = state.getInitialTheme().value();
+
+    helpers::assertThat(rt, state.hasTheme(selectedTheme), "you're trying to select theme '" + selectedTheme + "' but it wasn't registered.");
+
+    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("unable to set adaptive theme as your device doesn't support it.");
+    }
+}
+
+void HybridStyleSheet::loadExternalMethods(const jsi::Value& thisValue, jsi::Runtime& rt) {
+    auto jsMethods = thisValue.getObject(rt).getProperty(rt, "jsMethods");
+
+    helpers::assertThat(rt, jsMethods.isObject(), "can't find jsMethods.");
+
+    auto maybeProcessColorFn = jsMethods.asObject(rt).getProperty(rt, "processColor");
+
+    helpers::assertThat(rt, maybeProcessColorFn.isObject(), "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 dependencyMap = registry.buildDependencyMap(dependencies);
+    auto& rt = this->_unistylesRuntime->getRuntime();
+
+    if (dependencyMap.size() == 0) {
+        return;
+    }
+
+    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap);
+
+    auto shadowLeafUpdates = parser.dependencyMapToShadowLeafUpdates(dependencyMap);
+
+    shadow::ShadowTreeManager::updateShadowTree(rt, shadowLeafUpdates);
+}
+
+void HybridStyleSheet::registerCommitHook(jsi::Runtime &rt) {
+    UIManager& uiManager = const_cast<UIManager&>(UIManagerBinding::getBinding(rt)->getUIManager());
+
+    this->_unistylesCommitHook = std::make_shared<core::UnistylesCommitHook>(uiManager, this->_unistylesRuntime);
+}

package/cxx/hybridObjects/HybridStyleSheet.h

@@ -0,0 +1,61 @@
+#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"
+
+using namespace margelo::nitro::unistyles;
+using namespace facebook::react;
+
+struct HybridStyleSheet: public HybridUnistylesStyleSheetSpec {
+    HybridStyleSheet(std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
+      : HybridObject(TAG), _unistylesRuntime{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);
+    void registerCommitHook(jsi::Runtime& rt);
+
+    double __unid = -1;
+    std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+    std::shared_ptr<core::UnistylesCommitHook> _unistylesCommitHook;
+};
+