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

package/cxx/core/MediaQueries.cpp

@@ -0,0 +1,87 @@
+#include "MediaQueries.h"
+
+using namespace margelo::nitro::unistyles;
+
+bool core::UnistylesMQ::isMQ() {
+    return this->isValid;
+}
+
+bool core::UnistylesMQ::checkIsMQ(const std::string& maybeMQ) {
+    std::regex pattern(R"(:([hw])\[(\d+)(?:,\s*(\d+|Infinity))?\])");
+
+    return std::regex_search(maybeMQ, pattern);
+}
+
+bool core::UnistylesMQ::checkIsValidMQ() {
+    if (parsedMQ->width && parsedMQ->height) {
+        return parsedMQ->width->from <= parsedMQ->width->to && parsedMQ->height->from <= parsedMQ->height->to;
+    }
+
+    if (parsedMQ->width) {
+        return parsedMQ->width->from <= parsedMQ->width->to;
+    }
+
+    if (parsedMQ->height) {
+        return parsedMQ->height->from <= parsedMQ->height->to;
+    }
+    
+    return false;
+}
+
+void core::UnistylesMQ::parseMQ(const std::string& maybeMQ) {
+    const std::regex UNISTYLES_WIDTH_REGEX(R"(:(w)\[(\d+)(?:,\s*(\d+|Infinity))?\])");
+    const std::regex UNISTYLES_HEIGHT_REGEX(R"(:(h)\[(\d+)(?:,\s*(\d+|Infinity))?\])");
+
+    ParsedMQ result;
+    std::smatch match;
+
+    if (std::regex_search(maybeMQ, match, UNISTYLES_WIDTH_REGEX)) {
+        double from = std::stod(match[2]);
+        double to = match[3].matched
+        ? (match[3] == "Infinity" ? std::numeric_limits<double>::infinity(): std::stod(match[3]))
+        : from;
+        
+        result.width = ParsedMQDimension{from, to};
+    }
+
+    if (std::regex_search(maybeMQ, match, UNISTYLES_HEIGHT_REGEX)) {
+        double from = std::stod(match[2]);
+        double to = match[3].matched
+        ? (match[3] == "Infinity" ? std::numeric_limits<double>::infinity() : std::stod(match[3]))
+        : from;
+
+        result.height = ParsedMQDimension{from, to};
+    }
+    
+    this->parsedMQ = result;
+}
+
+bool core::UnistylesMQ::isWithinScreenWidth(const ParsedMQDimension& width, double screenWidth) {
+    return screenWidth >= width.from && screenWidth <= width.to;
+}
+
+bool core::UnistylesMQ::isWithinScreenHeight(const ParsedMQDimension& height, double screenHeight) {
+    return screenHeight >= height.from && screenHeight <= height.to;
+}
+
+bool core::UnistylesMQ::isWithinTheWidthAndHeight(const Dimensions& screenSize) {
+    if (!isValid) {
+        return false;
+    }
+    
+    auto parsedMq = parsedMQ.value();
+    
+    if (parsedMq.width && parsedMq.height) {
+        return isWithinScreenWidth(*parsedMq.width, screenSize.width) && isWithinScreenHeight(*parsedMq.height, screenSize.height);
+    }
+
+    if (parsedMq.width) {
+        return isWithinScreenWidth(*parsedMq.width, screenSize.width);
+    }
+
+    if (parsedMq.height) {
+        return isWithinScreenHeight(*parsedMq.height, screenSize.height);
+    }
+
+    return false;
+}

package/cxx/core/MediaQueries.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <optional>
+#include <regex>
+#include "Dimensions.hpp"
+
+namespace margelo::nitro::unistyles::core {
+
+struct ParsedMQDimension {
+    double from;
+    double to;
+};
+
+struct ParsedMQ {
+    std::optional<ParsedMQDimension> width;
+    std::optional<ParsedMQDimension> height;
+};
+
+struct UnistylesMQ {
+    UnistylesMQ(const std::string& maybeMQ) {
+        if (!this->checkIsMQ(maybeMQ)) {
+            return;
+        }
+        
+        this->parseMQ(maybeMQ);
+        
+        if (!this->checkIsValidMQ()) {
+            return;
+        }
+        
+        this->isValid = true;
+    }
+
+    bool isMQ();
+    bool isWithinTheWidthAndHeight(const Dimensions& screenSize);
+    
+private:
+    bool isValid = false;
+    std::optional<ParsedMQ> parsedMQ;
+    bool checkIsValidMQ();
+    bool checkIsMQ(const std::string& maybeMQ);
+    void parseMQ(const std::string& maybeMQ);
+    bool isWithinScreenWidth(const ParsedMQDimension& width, double screenWidth);
+    bool isWithinScreenHeight(const ParsedMQDimension& height, double screenHeight);
+};
+
+}

package/cxx/core/StyleSheet.h

@@ -0,0 +1,31 @@
+#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{};
+};
+
+}

package/cxx/core/StyleSheetRegistry.cpp

@@ -0,0 +1,42 @@
+#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, int unid) {
+    if (rawStyleSheet.isFunction(rt)) {
+        return this->addFromFunction(rt, unid, rawStyleSheet.asFunction(rt));
+    }
+
+    return this->addFromObject(rt, unid, std::move(rawStyleSheet));
+}
+
+std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromFunction(jsi::Runtime& rt, int unid, jsi::Function styleSheetFn) {
+    auto numberOfArgs = styleSheetFn.getProperty(rt, "length").getNumber();
+
+    helpers::assertThat(rt, numberOfArgs <= 2, "StyleSheet.create 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(rt, unid, core::StyleSheetType::Static, std::move(staticStyleSheet));
+    }
+
+    // stylesheet depends only on theme
+    if (numberOfArgs == 1) {
+        return registry.addStyleSheet(rt, unid, core::StyleSheetType::Themable, std::move(styleSheetFn));
+    }
+
+    // stylesheet depends on theme and mini runtime
+    return registry.addStyleSheet(rt, unid, core::StyleSheetType::ThemableWithMiniRuntime, std::move(styleSheetFn));
+}
+
+std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromObject(jsi::Runtime& rt, int tag, jsi::Object rawStyleSheet) {
+    auto& registry = UnistylesRegistry::get();
+    
+    return registry.addStyleSheet(rt, 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, int unid);
+    
+private:
+    virtual std::shared_ptr<StyleSheet> addFromFunction(jsi::Runtime& rt, int unid, jsi::Function styleSheetFn);
+    virtual std::shared_ptr<StyleSheet> addFromObject(jsi::Runtime& rt, int unid, jsi::Object rawStyleSheet);
+};
+
+}

package/cxx/core/Unistyle.h

@@ -0,0 +1,75 @@
+#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 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;
+};
+
+}

package/cxx/core/UnistyleData.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include "Unistyle.h"
+
+namespace margelo::nitro::unistyles::core {
+
+using Variants = std::vector<std::pair<std::string, std::string>>;
+
+struct UnistyleData {
+    UnistyleData(Unistyle::Shared unistyle, const Variants& variants, std::vector<folly::dynamic>& arguments)
+        : unistyle{unistyle}, variants(std::move(variants)), dynamicFunctionMetadata{std::move(arguments)} {}
+
+    UnistyleData(const UnistyleData&) = delete;
+    UnistyleData(UnistyleData&& other): unistyle{other.unistyle}, variants(std::move(other.variants)) {}
+
+    core::Unistyle::Shared unistyle;
+    core::Variants variants;
+    std::optional<jsi::Object> parsedStyle = std::nullopt;
+    std::optional<std::vector<folly::dynamic>> 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,54 @@
+#include "UnistylesCommitHook.h"
+
+using namespace margelo::nitro::unistyles;
+using namespace facebook::react;
+
+core::UnistylesCommitHook::~UnistylesCommitHook() noexcept {
+    _uiManager->unregisterCommitHook(*this);
+}
+
+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();
+        unistylesRootNode->addUnistylesMountTrait();
+        
+        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& rt = this->_unistylesRuntime->getRuntime();
+    auto parser = parser::Parser(this->_unistylesRuntime);
+    auto dependencyMap = registry.buildDependencyMap(rt);
+    
+    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap);
+    
+    return parser.dependencyMapToShadowLeafUpdates(dependencyMap);
+}

package/cxx/core/UnistylesCommitHook.h

@@ -0,0 +1,32 @@
+#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(std::shared_ptr<UIManager> uiManager, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
+        : _unistylesRuntime{unistylesRuntime}, _uiManager{uiManager} {
+            _uiManager->registerCommitHook(*this);
+        }
+    
+    ~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;
+    std::shared_ptr<UIManager> _uiManager;
+};
+
+}

package/cxx/core/UnistylesCommitShadowNode.h

@@ -0,0 +1,39 @@
+#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};
+constexpr shadow::ShadowNodeTraits::Trait UnistylesMountTrait{1 << 31};
+
+struct UnistylesCommitShadowNode: public shadow::ShadowNode {
+    inline void addUnistylesCommitTrait() {
+        traits_.set(UnistylesCommitTrait);
+    }
+    
+    inline void removeUnistylesCommitTrait() {
+        traits_.unset(UnistylesCommitTrait);
+    }
+    
+    inline bool hasUnistylesCommitTrait() {
+        return traits_.check(UnistylesCommitTrait);
+    }
+    
+    inline void addUnistylesMountTrait() {
+        traits_.set(UnistylesMountTrait);
+    }
+    
+    inline void removeUnistylesMountTrait() {
+        traits_.unset(UnistylesMountTrait);
+    }
+    
+    inline bool hasUnistylesMountTrait() {
+        return traits_.check(UnistylesMountTrait);
+    }
+};
+
+}

package/cxx/core/UnistylesMountHook.cpp

@@ -0,0 +1,40 @@
+#include "UnistylesMountHook.h"
+#include "ShadowTreeManager.h"
+
+using namespace margelo::nitro::unistyles;
+using namespace facebook::react;
+
+core::UnistylesMountHook::~UnistylesMountHook() noexcept {
+    _uiManager->unregisterMountHook(*this);
+}
+
+void core::UnistylesMountHook::shadowTreeDidMount(RootShadowNode::Shared const &rootShadowNode, double mountTime) noexcept {
+    auto rootNode = std::const_pointer_cast<RootShadowNode>(rootShadowNode);
+    auto unistylesRootNode = std::reinterpret_pointer_cast<core::UnistylesCommitShadowNode>(rootNode);
+
+    // skip only unistyles commits
+    if (unistylesRootNode->hasUnistylesMountTrait()) {
+        unistylesRootNode->removeUnistylesMountTrait();
+
+        return;
+    }
+
+    auto shadowLeafUpdates = this->getUnistylesUpdates();
+
+    if (shadowLeafUpdates.size() == 0) {
+        return;
+    }
+
+    shadow::ShadowTreeManager::updateShadowTree(this->_unistylesRuntime->getRuntime(), shadowLeafUpdates);
+}
+
+shadow::ShadowLeafUpdates core::UnistylesMountHook::getUnistylesUpdates() {
+    auto& registry = core::UnistylesRegistry::get();
+    auto& rt = this->_unistylesRuntime->getRuntime();
+    auto parser = parser::Parser(this->_unistylesRuntime);
+    auto dependencyMap = registry.buildDependencyMap(rt);
+
+    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap);
+
+    return parser.dependencyMapToShadowLeafUpdates(dependencyMap);
+}

package/cxx/core/UnistylesMountHook.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <react/renderer/uimanager/UIManager.h>
+#include <react/renderer/uimanager/UIManagerMountHook.h>
+#include "HybridUnistylesRuntime.h"
+#include "Parser.h"
+#include "ShadowTreeManager.h"
+
+namespace margelo::nitro::unistyles::core {
+
+using namespace facebook::react;
+
+struct UnistylesMountHook : public UIManagerMountHook {
+    UnistylesMountHook(std::shared_ptr<UIManager> uiManager, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
+        : _unistylesRuntime{unistylesRuntime}, _uiManager{uiManager} {
+            _uiManager->registerMountHook(*this);
+        }
+
+    ~UnistylesMountHook() noexcept override;
+
+    void shadowTreeDidMount(RootShadowNode::Shared const &rootShadowNode, double mountTime) noexcept override;
+
+    shadow::ShadowLeafUpdates getUnistylesUpdates();
+
+private:
+    std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+    std::shared_ptr<UIManager> _uiManager;
+};
+
+}