react-native-unistyles 3.0.0-alpha.6 → 3.0.0-alpha.8

package/cxx/common/Helpers.h

@@ -7,6 +7,8 @@ using namespace facebook;
 
 namespace margelo::nitro::unistyles::helpers {
 
+using Variants = std::vector<std::pair<std::string, std::string>>;
+
 inline void assertThat(jsi::Runtime& rt, bool condition, const std::string& message) {
     if (!condition) {
         throw jsi::JSError(rt, message);
@@ -90,4 +92,26 @@ inline bool isPlatformColor(jsi::Runtime& rt, jsi::Object& maybePlatformColor) {
     return maybePlatformColor.hasProperty(rt, "resource_paths") && maybePlatformColor.getProperty(rt, "resource_paths").isObject();
 }
 
+inline Variants variantsToPairs(jsi::Runtime& rt, jsi::Object&& variants) {
+    Variants pairs{};
+
+    helpers::enumerateJSIObject(rt, variants, [&](const std::string& variantName, jsi::Value& variantValue){
+        if (variantValue.isUndefined() || variantValue.isNull()) {
+            return;
+        }
+
+        if (variantValue.isBool()) {
+            pairs.emplace_back(std::make_pair(variantName, variantValue.asBool() ? "true" : "false"));
+
+            return;
+        }
+
+        if (variantValue.isString()) {
+            pairs.emplace_back(std::make_pair(variantName, variantValue.asString(rt).utf8(rt)));
+        }
+    });
+
+    return pairs;
+}
+
 }

package/cxx/core/HostStyle.cpp

@@ -42,15 +42,14 @@ jsi::Function HostStyle::createAddVariantsProxyFunction(jsi::Runtime& rt) {
         helpers::assertThat(rt, arguments[0].isObject(), "Unistyles: useVariants expected to be called with object.");
 
         auto parser = parser::Parser(this->_unistylesRuntime);
-        auto pairs = parser.variantsToPairs(rt, arguments[0].asObject(rt));
+        auto pairs = helpers::variantsToPairs(rt, arguments[0].asObject(rt));
 
-        if (pairs == this->_styleSheet->variants) {
+        if (pairs == this->_variants) {
             return jsi::Value::undefined();
         }
 
-        this->_styleSheet->variants = pairs;
-
-        parser.rebuildUnistylesWithVariants(rt, this->_styleSheet);
+        this->_variants = pairs;
+        parser.rebuildUnistylesWithVariants(rt, this->_styleSheet, this->_variants);
 
         return jsi::Value::undefined();
     });

package/cxx/core/HostStyle.h

@@ -8,6 +8,8 @@
 
 namespace margelo::nitro::unistyles::core {
 
+using Variants = std::vector<std::pair<std::string, std::string>>;
+
 struct JSI_EXPORT HostStyle : public jsi::HostObject {
     HostStyle(std::shared_ptr<StyleSheet> styleSheet, std::shared_ptr<HybridUnistylesRuntime> unistylesRuntime)
         : _styleSheet{styleSheet}, _unistylesRuntime{unistylesRuntime} {};
@@ -20,6 +22,8 @@ struct JSI_EXPORT HostStyle : public jsi::HostObject {
 private:
     std::shared_ptr<StyleSheet> _styleSheet;
     std::shared_ptr<HybridUnistylesRuntime> _unistylesRuntime;
+    std::vector<std::pair<std::string, std::string>> _variants{};
+    
 };
 
 }

package/cxx/core/StyleSheet.h

@@ -26,7 +26,6 @@ struct StyleSheet {
     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

@@ -4,17 +4,15 @@
 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;
-
+std::shared_ptr<StyleSheet> StyleSheetRegistry::addStyleSheetFromValue(jsi::Runtime& rt, jsi::Object rawStyleSheet, int unid) {
     if (rawStyleSheet.isFunction(rt)) {
-        return this->addFromFunction(rt, ++tag, rawStyleSheet.asFunction(rt));
+        return this->addFromFunction(rt, unid, rawStyleSheet.asFunction(rt));
     }
 
-    return this->addFromObject(rt, ++tag, std::move(rawStyleSheet));
+    return this->addFromObject(rt, unid, std::move(rawStyleSheet));
 }
 
-std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromFunction(jsi::Runtime& rt, unsigned int tag, jsi::Function styleSheetFn) {
+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.");
@@ -25,26 +23,20 @@ std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromFunction(jsi::Runtime& rt
     if (numberOfArgs == 0) {
         auto staticStyleSheet = styleSheetFn.call(rt).asObject(rt);
 
-        return registry.addStyleSheet(tag, core::StyleSheetType::Static, std::move(staticStyleSheet));
+        return registry.addStyleSheet(rt, unid, core::StyleSheetType::Static, std::move(staticStyleSheet));
     }
 
     // stylesheet depends only on theme
     if (numberOfArgs == 1) {
-        return registry.addStyleSheet(tag, core::StyleSheetType::Themable, std::move(styleSheetFn));
+        return registry.addStyleSheet(rt, unid, 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));
+    return registry.addStyleSheet(rt, unid, core::StyleSheetType::ThemableWithMiniRuntime, std::move(styleSheetFn));
 }
 
-void StyleSheetRegistry::removeStyleSheetByTag(unsigned int tag) {
+std::shared_ptr<StyleSheet> StyleSheetRegistry::addFromObject(jsi::Runtime& rt, int tag, jsi::Object rawStyleSheet) {
     auto& registry = UnistylesRegistry::get();
     
-    registry.removeStyleSheet(tag);
+    return registry.addStyleSheet(rt, tag, core::StyleSheetType::Static, std::move(rawStyleSheet));
 }

package/cxx/core/StyleSheetRegistry.h

@@ -16,12 +16,11 @@ struct StyleSheetRegistry {
     StyleSheetRegistry(const StyleSheetRegistry&) = delete;
     StyleSheetRegistry(StyleSheetRegistry&&) = delete;
 
-    virtual std::shared_ptr<StyleSheet> addStyleSheetFromValue(jsi::Runtime& rt, jsi::Object rawStyleSheet);
-    virtual void removeStyleSheetByTag(unsigned int tag);
+    virtual std::shared_ptr<StyleSheet> addStyleSheetFromValue(jsi::Runtime& rt, jsi::Object rawStyleSheet, int unid);
     
 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);
+    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/UnistyleData.h

@@ -0,0 +1,22 @@
+#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)
+        : unistyle{unistyle}, variants(std::move(variants)) {}
+
+    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;
+};
+
+}

package/cxx/core/UnistylesCommitHook.cpp

@@ -43,8 +43,11 @@ RootShadowNode::Unshared core::UnistylesCommitHook::shadowTreeWillCommit(
 
 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();
+    auto dependencyMap = registry.buildDependencyMap(rt);
+    
+    parser.rebuildUnistylesInDependencyMap(rt, dependencyMap);
     
     return parser.dependencyMapToShadowLeafUpdates(dependencyMap);
 }

package/cxx/core/UnistylesRegistry.cpp

@@ -5,11 +5,6 @@ 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);
 
@@ -62,64 +57,54 @@ void core::UnistylesRegistry::createState(jsi::Runtime& 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) {
+void core::UnistylesRegistry::linkShadowNodeWithUnistyle(
+    const ShadowNodeFamily* shadowNodeFamily,
+    const core::Unistyle::Shared unistyle,
+    Variants& variants
+) {
     if (!this->_shadowRegistry.contains(shadowNodeFamily)) {
         this->_shadowRegistry[shadowNodeFamily] = {};
     }
-    
-    this->_shadowRegistry[shadowNodeFamily].emplace_back(unistyle);
+
+    this->_shadowRegistry[shadowNodeFamily].emplace_back(std::make_pair(unistyle, std::move(variants)));
 }
 
 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);
-    
+    auto it = std::find_if(unistylesVec.begin(), unistylesVec.end(), [unistyle](std::pair<core::Unistyle::Shared, Variants> pair){
+        return pair.first == 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)));
+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.back();
+    return this->_styleSheetRegistry[&rt][unid];
 }
 
-void core::UnistylesRegistry::removeStyleSheet(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.");
-    }
-
-    this->_styleSheetRegistry.erase(it);
-}
-    
-DependencyMap core::UnistylesRegistry::buildDependencyMap(std::vector<UnistyleDependency>& deps) {
+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) {
+
+    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
@@ -130,21 +115,21 @@ DependencyMap core::UnistylesRegistry::buildDependencyMap(std::vector<UnistyleDe
                     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& shadowUnistyle : unistyles) {
+
+                for (const auto& [shadowUnistyle, variants] : unistyles) {
                     if (unistyle != shadowUnistyle) {
                         continue;
                     }
 
-                    dependencyMap[styleSheet][family].push_back(shadowUnistyle);
+                    dependencyMap[styleSheet][family].emplace_back(unistyle, variants);
                 }
             }
         }
@@ -153,21 +138,20 @@ DependencyMap core::UnistylesRegistry::buildDependencyMap(std::vector<UnistyleDe
     return dependencyMap;
 }
 
-DependencyMap core::UnistylesRegistry::buildDependencyMap() {
+core::DependencyMap core::UnistylesRegistry::buildDependencyMap(jsi::Runtime& rt) {
     DependencyMap dependencyMap;
- 
-    for (const auto& styleSheet : this->_styleSheetRegistry) {
+
+    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& shadowUnistyle : unistyles) {
+
+                for (const auto& [shadowUnistyle, variants] : unistyles) {
                     if (unistyle != shadowUnistyle) {
                         continue;
                     }
 
-                    // make sure to use base Unistyle class
-                    dependencyMap[styleSheet][family].push_back(shadowUnistyle);
+                    dependencyMap[styleSheet][family].emplace_back(unistyle, variants);
                 }
             }
         }

package/cxx/core/UnistylesRegistry.h

@@ -9,6 +9,7 @@
 #include "StyleSheetRegistry.h"
 #include "StyleSheet.h"
 #include "Unistyle.h"
+#include "UnistyleData.h"
 
 namespace margelo::nitro::unistyles::core {
 
@@ -19,7 +20,7 @@ using namespace facebook::react;
 
 using DependencyMap = std::unordered_map<
     std::shared_ptr<core::StyleSheet>,
-    std::unordered_map<const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>>
+    std::unordered_map<const ShadowNodeFamily*, std::vector<UnistyleData>>
 >;
 
 struct UnistylesRegistry: public StyleSheetRegistry {
@@ -36,19 +37,18 @@ struct UnistylesRegistry: public StyleSheetRegistry {
 
     UnistylesState& getState(jsi::Runtime& rt);
     void createState(jsi::Runtime& rt);
-    void linkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared);
+    void linkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared, Variants& variants);
     void unlinkShadowNodeWithUnistyle(const ShadowNodeFamily*, const core::Unistyle::Shared);
-    std::shared_ptr<core::StyleSheet> addStyleSheet(int tag, core::StyleSheetType type, jsi::Object&& rawValue);
-    void removeStyleSheet(int tag);
-    DependencyMap buildDependencyMap(std::vector<UnistyleDependency>& deps);
-    DependencyMap buildDependencyMap();
+    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::vector<std::shared_ptr<core::StyleSheet>> _styleSheetRegistry{};
-    std::unordered_map<const ShadowNodeFamily*, std::vector<core::Unistyle::Shared>> _shadowRegistry{};
+    std::unordered_map<jsi::Runtime*, std::unordered_map<int, std::shared_ptr<core::StyleSheet>>> _styleSheetRegistry{};
+    std::unordered_map<const ShadowNodeFamily*, std::vector<std::pair<core::Unistyle::Shared, Variants>>> _shadowRegistry{};
 };
 
 UnistylesRegistry& UnistylesRegistry::get() {

package/cxx/hybridObjects/HybridShadowRegistry.cpp

@@ -4,20 +4,21 @@ 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 == 2, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected two arguments.");
+    helpers::assertThat(rt, count == 3, "Unistyles: Invalid babel transform 'ShadowRegistry link' expected 3 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& registry = core::UnistylesRegistry::get();
     
-    registry.linkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper);
+    registry.linkShadowNodeWithUnistyle(&shadowNodeWrapper->getFamily(), unistyleWrapper, variants);
     
     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 two arguments.");
+    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]);

package/cxx/hybridObjects/HybridStyleSheet.cpp

@@ -13,20 +13,17 @@ 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, count == 1, "StyleSheet.create expected to be called with one argument.");
+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();
-
-    // this might happen only when hot reloading
-    if (this->__unid != -1) {
-        registry.removeStyleSheet(this->__unid);
-    }
+    int unid = arguments[1].asNumber();
 
     jsi::Object rawStyleSheet = arguments[0].asObject(rt);
-    auto registeredStyleSheet = registry.addStyleSheetFromValue(rt, std::move(rawStyleSheet));
+    auto registeredStyleSheet = registry.addStyleSheetFromValue(rt, std::move(rawStyleSheet), unid);
 
     this->__unid = registeredStyleSheet->tag;
 
@@ -225,12 +222,12 @@ void HybridStyleSheet::onPlatformDependenciesChange(std::vector<UnistyleDependen
 
     // 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(dependencies);
+
+    auto dependencyMap = registry.buildDependencyMap(rt, dependencies);
 
     if (dependencyMap.size() == 0) {
         return;